/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/SimDataFormats/SLHC/interface/L1TkCluster.h

Go to the documentation of this file.

#ifndef STACKED_TRACKER_L1TK_CLUSTER_FORMAT_H
#define STACKED_TRACKER_L1TK_CLUSTER_FORMAT_H

#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/Common/interface/DetSet.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/SiPixelDigi/interface/PixelDigi.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"

#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"


  template< typename T >
  class L1TkCluster
  {
    public:
      L1TkCluster();
      L1TkCluster( std::vector< T > aHits, DetId aDetId, unsigned int aStackMember );

      ~L1TkCluster();


      std::vector< T > getHits() const;
      void             setHits( std::vector< T > aHits );

      DetId        getDetId() const;
      void         setDetId( DetId aDetId );
      unsigned int getStackMember() const;
      void         setStackMember( unsigned int aStackMember );

      std::vector< edm::Ptr< SimTrack > > getSimTrackPtrs() const;
      void                                addSimTrack( const edm::Ptr< SimTrack > &trk) { theSimTracks.push_back(trk);}
      bool                                isGenuine() const;
      bool                                isCombinatoric() const;
      bool                                isUnknown() const;
      int                                 findType() const;
      unsigned int                        findSimTrackId() const;

      unsigned int findWidth() const;

      MeasurementPoint findHitLocalCoordinates( unsigned int hitIdx ) const;

      MeasurementPoint findAverageLocalCoordinates() const;

      std::string print( unsigned int i=0 ) const;

    private:
      std::vector< T >                    theHits;
      DetId                               theDetId;
      unsigned int                        theStackMember;
      std::vector< edm::Ptr< SimTrack > > theSimTracks;

  }; 



  template< typename T >
  L1TkCluster< T >::L1TkCluster()
  {
    theHits.clear();
    theDetId = 0;
    theStackMember = 0;
    theSimTracks.clear();
  }

  template< typename T >
  L1TkCluster< T >::L1TkCluster( std::vector< T > aHits, DetId aDetId, unsigned int aStackMember )
  {
    theHits.clear();
    for ( unsigned int j = 0; j < aHits.size(); j++ )
      theHits.push_back( aHits.at(j) );
    theDetId = aDetId;
    theStackMember = aStackMember;
    theSimTracks.clear();
  }

  template< typename T >
  L1TkCluster< T >::~L1TkCluster(){}

  template< typename T >
  std::vector< T > L1TkCluster< T >::getHits() const { return theHits; }

  template< typename T >
  void L1TkCluster< T >::setHits( std::vector< T > aHits )
  {
    for ( unsigned int j=0; j<aHits.size(); j++ )
      theHits.push_back( aHits.at(j) );
  }

  template< typename T >
  DetId L1TkCluster< T >::getDetId() const { return theDetId; }

  template< typename T >
  void L1TkCluster< T >::setDetId( DetId aDetId ) { theDetId = aDetId; }

  template< typename T >
  unsigned int L1TkCluster< T >::getStackMember() const { return theStackMember; }

  template< typename T >
  void L1TkCluster< T >::setStackMember( unsigned int aStackMember ) { theStackMember = aStackMember; }

  template< typename T >
  std::vector< edm::Ptr< SimTrack > > L1TkCluster< T >::getSimTrackPtrs() const { return theSimTracks; }

  template< typename T >
  bool L1TkCluster< T >::isGenuine() const
  {
    int prevTrack = -99999; // SimTrackId storage
    if ( theSimTracks.size() == 0 ) return false;
    for ( unsigned int k = 0; k < theSimTracks.size(); k++ )
    {
      edm::Ptr< SimTrack > curSimTrackPtr = theSimTracks.at(k);
      if ( curSimTrackPtr.isNull() )
        return false;
      else
      {
        if ( theSimTracks.size() > 1 )
        {
          if ( prevTrack < 0 )
            prevTrack = curSimTrackPtr->trackId();

          if ( prevTrack != (int)curSimTrackPtr->trackId() )
            return false;
 
          prevTrack = curSimTrackPtr->trackId();
        }
      }
    }
    return true;
  }

  template< typename T >
  bool L1TkCluster< T >::isCombinatoric() const
  {
    int prevTrack = -99999; // SimTrackId storage
    unsigned int numberNulls = 0; // Number of non-found SimTracks
    unsigned int numberGoods = 0; // Number of found SimTracks
    for ( unsigned int k = 0; k < theSimTracks.size(); k++ )
    {
      edm::Ptr< SimTrack > curSimTrackPtr = theSimTracks.at(k);
      if ( curSimTrackPtr.isNull() )
        numberNulls++;
      else
        numberGoods++;

      if ( numberNulls > 0 && numberGoods > 0 )
        return true;

      if ( curSimTrackPtr.isNull() == false )
      {
        if ( theSimTracks.size() > 1 )
        {
          if ( prevTrack < 0 )
            prevTrack = curSimTrackPtr->trackId();

          if ( prevTrack != (int)curSimTrackPtr->trackId() )
            return true;

          prevTrack = curSimTrackPtr->trackId();
        }
      }
    }

    if ( numberNulls > 0 && numberGoods == 0 )
      return false;

    return false;
  }

  template< typename T >
  bool L1TkCluster< T >::isUnknown() const
  {
    for ( unsigned int k = 0; k < theSimTracks.size(); k++ )
    {
      edm::Ptr< SimTrack > curSimTrackPtr = theSimTracks.at(k);
      if ( curSimTrackPtr.isNull() == false )
        return false;
    }
    return true;
  }

  template< typename T >
  int L1TkCluster< T >::findType() const
  {
    if ( this->isGenuine() && theSimTracks.size()>0 )
      return theSimTracks.at(0)->type();
    return 999999999;
  }

  template< typename T >
  unsigned int L1TkCluster< T >::findSimTrackId() const
  {
    if ( this->isGenuine() && theSimTracks.size()>0 )
      return theSimTracks.at(0)->trackId();
    return 0;
  }

  template<>
  unsigned int L1TkCluster< edm::Ref<edm::PSimHitContainer> >::findWidth() const;

  template< typename T >
  unsigned int L1TkCluster< T >::findWidth() const
  {
    int rowMin = 99999999;
    int rowMax = 0;
    for ( unsigned int i=0; i<theHits.size(); i++ )
    {
      if ( theHits.at(i)->row() < rowMin )
        rowMin = theHits.at(i)->row();
      if ( theHits.at(i)->row() > rowMax )
        rowMax = theHits.at(i)->row();
    }
    return abs( rowMax - rowMin + 1 ); 
  }

  template<>
  MeasurementPoint L1TkCluster< edm::Ref< edm::PSimHitContainer > >::findHitLocalCoordinates( unsigned int hitIdx ) const;

  template< typename T >
  MeasurementPoint L1TkCluster< T >::findHitLocalCoordinates( unsigned int hitIdx ) const
  {
    MeasurementPoint mp( theHits.at(hitIdx)->row(), theHits.at(hitIdx)->column() );
    return mp;
  }


  template<>
  MeasurementPoint L1TkCluster< edm::Ref< edm::PSimHitContainer > >::findAverageLocalCoordinates() const;

  template< typename T >
  MeasurementPoint L1TkCluster< T >::findAverageLocalCoordinates() const
  {
    double averageCol = 0.0;
    double averageRow = 0.0;

    if ( theHits.size() != 0 )
    {
      typename std::vector< T >::const_iterator hitIter;
      for ( hitIter = theHits.begin();
            hitIter != theHits.end();
            hitIter++ )
      {
        averageCol += (*hitIter)->column();
        averageRow += (*hitIter)->row();
      }
      averageCol /= theHits.size();
      averageRow /= theHits.size();
    }
    return MeasurementPoint( averageRow, averageCol );
  }


  template< typename T >
  std::string L1TkCluster< T >::print( unsigned int i ) const
  {
    std::string padding("");
    for ( unsigned int j=0; j!=i; ++j )
      padding+="\t";
    std::stringstream output;
    output<<padding<<"L1TkCluster:\n";
    padding+='\t';
    output << padding << "DetId: " << theDetId.rawId() << '\n';
    output << padding << "member: " << theStackMember << ", cluster size: " << theHits.size() << '\n';
    return output.str();
  }

  template< typename T >
  std::ostream& operator << (std::ostream& os, const L1TkCluster< T >& aL1TkCluster) { return ( os<<aL1TkCluster.print() ); }



#endif