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

Go to the documentation of this file.

#ifndef STACKED_TRACKER_L1TK_STUB_FORMAT_H
#define STACKED_TRACKER_L1TK_STUB_FORMAT_H

#include "DataFormats/SiPixelDetId/interface/StackedTrackerDetId.h"
#include "CLHEP/Units/PhysicalConstants.h"

#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"
#include "SimDataFormats/SLHC/interface/L1TkCluster.h"

  template< typename T >
  class L1TkStub
  {
    public:
      L1TkStub();
      L1TkStub( DetId aDetId );

      ~L1TkStub();


      std::vector< edm::Ptr< L1TkCluster< T > > > getClusterPtrs() const;
      const edm::Ptr< L1TkCluster< T > >&         getClusterPtr( unsigned int hitIdentifier ) const;
      void                                        addClusterPtr( edm::Ptr< L1TkCluster< T > > aL1TkCluster );


      DetId getDetId() const;
      void  setDetId( DetId aDetId );

      double getTriggerDisplacement() const; 
      void   setTriggerDisplacement( int aDisplacement ); 
      double getTriggerOffset() const; 
      void   setTriggerOffset( int anOffset ); 

      edm::Ptr< SimTrack > getSimTrackPtr() const;
      bool                 isGenuine() const;
      bool                 isCombinatoric() const;
      bool                 isUnknown() const;
      int                  findType() const;
      unsigned int         findSimTrackId() const;

      void checkSimTrack();

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

    private:
      DetId                                       theDetId;
      std::vector< edm::Ptr< L1TkCluster< T > > > theClusters;
      edm::Ptr< SimTrack >                        theSimTrack;
      int                                         theDisplacement;
      int                                         theOffset;

  }; 


  template< typename T >
  L1TkStub< T >::L1TkStub()
  {
    theDetId = 0;
    theClusters.clear();
    theDisplacement = 999999;
    theOffset = 0;
  }

  template< typename T >
  L1TkStub< T >::L1TkStub( DetId aDetId )
  {
    theDetId = aDetId;
    theClusters.clear();
    theDisplacement = 999999;
    theOffset = 0;
  }

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

  template< typename T >
  std::vector< edm::Ptr< L1TkCluster< T > > > L1TkStub< T >::getClusterPtrs() const { return theClusters; }

  template< typename T >
  const edm::Ptr< L1TkCluster< T > >& L1TkStub< T >::getClusterPtr( unsigned int hitIdentifier ) const
  {
    typename std::vector< edm::Ptr< L1TkCluster< T > > >::const_iterator clusIter;
    for ( clusIter = theClusters.begin();
          clusIter != theClusters.end();
          ++clusIter )
    {
      if ( (*clusIter)->getStackMember() == hitIdentifier )
        return *clusIter;
    }
    return edm::Ptr< L1TkCluster< T > >();
  }

  template< typename T >
  void L1TkStub< T >::addClusterPtr( edm::Ptr< L1TkCluster< T > > aL1TkCluster )
  {
    theClusters.push_back( aL1TkCluster );
  }

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

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

  template< typename T >
  double L1TkStub< T >::getTriggerDisplacement() const { return 0.5*theDisplacement; }

  template< typename T >
  void L1TkStub< T >::setTriggerDisplacement( int aDisplacement ) { theDisplacement = aDisplacement; }

  template< typename T >
  double L1TkStub< T >::getTriggerOffset() const { return 0.5*theOffset; }

  template< typename T >
  void L1TkStub< T >::setTriggerOffset( int anOffset ) { theOffset = anOffset; }

  template< typename T >
  edm::Ptr< SimTrack > L1TkStub< T >::getSimTrackPtr() const { return theSimTrack; }

  template< typename T >
  bool L1TkStub< T >::isGenuine() const
  {
    /*
    if ( theClusters.at(0)->isUnknown() || theClusters.at(1)->isUnknown() )
      return false;

    else
    {
      if ( theClusters.at(0)->isGenuine() && theClusters.at(1)->isGenuine() )
      {
        if ( theClusters.at(0)->findSimTrackId() == theClusters.at(1)->findSimTrackId() )
          return true;
        else
          return false;
      }
      else
      {
        int prevTrack = -99999; // SimTrackId storage
        std::vector< edm::Ptr< SimTrack > > innerSimTracks = theClusters.at(0)->getSimTrackPtrs();
        std::vector< edm::Ptr< SimTrack > > outerSimTracks = theClusters.at(1)->getSimTrackPtrs();
        for ( unsigned int i = 0; i < innerSimTracks.size(); i++ )
        {
          if ( innerSimTracks.at(i).isNull() );
            continue;
          for ( unsigned int j = 0; j < outerSimTracks.size(); j++ )
          {
            if ( outerSimTracks.at(j).isNull() );
              continue;

            if ( innerSimTracks.at(i)->trackId() == outerSimTracks.at(j)->trackId() )
            {
              if ( prevTrack < 0 )
                prevTrack = outerSimTracks.at(j)->trackId();

              if ( prevTrack != (int)outerSimTracks.at(j)->trackId() )
                return false;
            }
          }
        }
        if ( prevTrack < 0 )
          return false;
        else
          return true;
      }
    }
    std::cerr << "W A R N I N G! L1TkStub::isGenuine() \t we should never get here" << std::endl;
    return true;
    */

    if ( theSimTrack.isNull() )
      return false;

    return true;
  }

  template< typename T >
  bool L1TkStub< T >::isCombinatoric() const
  {
    if ( this->isGenuine() )
      return false;

    if ( theClusters.at(0)->isUnknown() && theClusters.at(1)->isUnknown() )
      return false;

    else if ( theClusters.at(0)->isUnknown() || theClusters.at(1)->isUnknown() )
      return true;

    else
    {
      if ( theClusters.at(0)->isGenuine() && theClusters.at(1)->isGenuine() )
      {
        if ( theClusters.at(0)->findSimTrackId() == theClusters.at(1)->findSimTrackId() )
          return false;
        else
          return true;
      }
      else
      {
        int prevTrack = -99999; // SimTrackId storage
        std::vector< edm::Ptr< SimTrack > > innerSimTracks = theClusters.at(0)->getSimTrackPtrs();
        std::vector< edm::Ptr< SimTrack > > outerSimTracks = theClusters.at(1)->getSimTrackPtrs();
        for ( unsigned int i = 0; i < innerSimTracks.size(); i++ )
        {
          if ( innerSimTracks.at(i).isNull() );
            continue;
          for ( unsigned int j = 0; j < outerSimTracks.size(); j++ )
          {
            if ( outerSimTracks.at(j).isNull() );
              continue;

            if ( innerSimTracks.at(i)->trackId() == outerSimTracks.at(j)->trackId() )
            {
              if ( prevTrack < 0 )
                prevTrack = outerSimTracks.at(j)->trackId();

              if ( prevTrack != (int)outerSimTracks.at(j)->trackId() )
                return true;
            }
          }
        }
        if ( prevTrack < 0 )
          return true;
        else
          return false;
      }
    }
    std::cerr << "W A R N I N G! L1TkStub::isCombinatoric() \t we should never get here" << std::endl;
    return false; 
  }

  template< typename T >
  bool L1TkStub< T >::isUnknown() const
  {
    return ( theClusters.at(0)->isUnknown() && theClusters.at(1)->isUnknown() );
  }

  template< typename T >
  int L1TkStub< T >::findType() const
  {
    if ( theSimTrack.isNull() )
      return 999999999;
    return theSimTrack->type();
  }

  template< typename T >
  unsigned int L1TkStub< T >::findSimTrackId() const
  {
    if ( theSimTrack.isNull() )
      return 0;
    return theSimTrack->trackId();
  }

  template< typename T >
  void L1TkStub< T >::checkSimTrack()
  {

    if ( theClusters.at(0)->isUnknown() || theClusters.at(1)->isUnknown() )
      return;

    else
    {
      if ( theClusters.at(0)->isGenuine() && theClusters.at(1)->isGenuine() )
      {
        if ( theClusters.at(0)->findSimTrackId() == theClusters.at(1)->findSimTrackId() )
        {
          std::vector< edm::Ptr< SimTrack > > curSimTracks = theClusters.at(0)->getSimTrackPtrs();
          for ( unsigned int k = 0; k < curSimTracks.size(); k++ )
          {
            if ( curSimTracks.at(k).isNull() == false )
            {
              theSimTrack = curSimTracks.at(k);
              return;
            }
          }
        }
        else
          return;
      }
      else
      {
        int prevTrack = -99999; // SimTrackId storage
        unsigned int whichSimTrack = 0;
        std::vector< edm::Ptr< SimTrack > > innerSimTracks = theClusters.at(0)->getSimTrackPtrs();
        std::vector< edm::Ptr< SimTrack > > outerSimTracks = theClusters.at(1)->getSimTrackPtrs();
        for ( unsigned int i = 0; i < innerSimTracks.size(); i++ )
        {
          if ( innerSimTracks.at(i).isNull() );
            continue;
          for ( unsigned int j = 0; j < outerSimTracks.size(); j++ )
          {
            if ( outerSimTracks.at(j).isNull() );
              continue;

            if ( innerSimTracks.at(i)->trackId() == outerSimTracks.at(j)->trackId() )
            {
              if ( prevTrack < 0 )
              {
                prevTrack = outerSimTracks.at(j)->trackId();
                whichSimTrack = j;
              }

              if ( prevTrack != (int)outerSimTracks.at(j)->trackId() )
                return;
            }
          }
        }
        if ( prevTrack < 0 )
          return;
        else
          theSimTrack = outerSimTracks.at(whichSimTrack);
      }
    }
  }


  template< typename T >
  std::string L1TkStub< T >::print( unsigned int i ) const
  {
    std::string padding("");
    for ( unsigned int j=0; j!=i; ++j )
      padding+="\t";
    std::stringstream output;
    output<<padding<<"L1TkStub:\n";
    padding+='\t';
    output << padding << "DetId: " << theDetId.rawId() << '\n';
    unsigned int iClu = 0;
    typename std::vector< edm::Ptr< L1TkCluster< T > > >::const_iterator clusIter;
    for ( clusIter = theClusters.begin(); clusIter!= theClusters.end(); ++clusIter )
      output << padding << "cluster: " << iClu++ << ", member: " << (*clusIter)->getStackMember() << ", cluster size: " << (*clusIter)->getHits().size() << '\n';
    return output.str();
  }

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



#endif