#include <TP.h>

Public Member Functions
unsigned int	countLayers (bool onlyPS=false)

const TrackingParticlePtr	getTrackingParticle () const

unsigned int	numAssocStubs () const

const TrackingParticlePtr	operator-> () const

bool	operator== (const TP &rhs) const

bool	physicsCollision () const

void	setMatchingStubs (const std::vector< Stub > &vMatchingStubs)

	TP ()

	TP (const TrackingParticlePtr &tpPtr, const AnalysisSettings &settings)

bool	use () const

bool	useForAlgEff () const

bool	useForEff () const

bool	useForVertexReco () const

	~TP ()

Private Member Functions
void	fillUse ()

void	fillUseForAlgEff ()

void	fillUseForEff ()

void	fillUseForVertexReco ()

Private Attributes
std::vector< Stub >	assocStubs_

bool	inTimeBx_

unsigned int	nLayersWithStubs_

bool	physicsCollision_

const AnalysisSettings *	settings_

TrackingParticlePtr	trackingParticle_

bool	use_

bool	useForAlgEff_

bool	useForEff_

bool	useForVertexReco_

Detailed Description

Definition at line 16 of file TP.h.

Constructor & Destructor Documentation

l1tVertexFinder::TP::TP ( )

Definition at line 5 of file TP.cc.

       : settings_(nullptr),
         inTimeBx_(false),
         physicsCollision_(false),
         use_(false),
         useForEff_(false),
         useForAlgEff_(false),
         useForVertexReco_(false),
         nLayersWithStubs_(0) {}

l1tVertexFinder::TP::TP	(	const TrackingParticlePtr &	tpPtr,
		const AnalysisSettings &	settings
	)

Definition at line 15 of file TP.cc.

References EncodedEventId::bunchCrossing(), runTauDisplay::eid, EncodedEventId::event(), fillUse(), fillUseForEff(), inTimeBx_, physicsCollision_, and trackingParticle_.

       : trackingParticle_(tpPtr), settings_(&settings) {
     const std::vector<SimTrack>& vst = trackingParticle_->g4Tracks();
     EncodedEventId eid = vst.at(0).eventId();
     inTimeBx_ = (eid.bunchCrossing() == 0);  // TP from in-time or out-of-time Bx.
     physicsCollision_ = (eid.event() == 0);  // TP from physics collision or from pileup.
 
     this->fillUse();        // Fill use_ flag, indicating if TP is worth keeping.
     this->fillUseForEff();  // Fill useForEff_ flag, indicating if TP is good for tracking efficiency measurement.
   }

l1tVertexFinder::TP::~TP ( )

inline

Definition at line 21 of file TP.h.

21 {}

Member Function Documentation

unsigned int l1tVertexFinder::TP::countLayers ( bool onlyPS = false )

Definition at line 39 of file TP.cc.

References assocStubs_, Exception, newFWLiteAna::found, l1tVertexFinder::AlgoSettings::layerIDfromRadiusBin(), settings_, l1tVertexFinder::AlgoSettings::trackerInnerRadius(), and l1tVertexFinder::AnalysisSettings::useLayerID().

Referenced by fillUseForAlgEff(), fillUseForVertexReco(), and setMatchingStubs().

                                           {
     //=== Unpack configuration parameters
 
     // Define layers using layer ID (true) or by bins in radius of 5 cm width (false).
     bool useLayerID = settings_->useLayerID();
     // When counting stubs in layers, actually histogram stubs in distance from beam-line with this bin size.
     float layerIDfromRadiusBin = settings_->layerIDfromRadiusBin();
     // Inner radius of tracker.
     float trackerInnerRadius = settings_->trackerInnerRadius();
 
     const int maxLayerID(30);
     std::vector<bool> foundLayers(maxLayerID, false);
 
     if (useLayerID) {
       // Count layers using CMSSW layer ID.
       for (const Stub& stub : assocStubs_) {
         if ((!onlyPS) || stub.psModule()) {  // Consider only stubs in PS modules if that option specified.
           int layerID = stub.layerId();
           if (layerID >= 0 && layerID < maxLayerID) {
             foundLayers[layerID] = true;
           } else {
             throw cms::Exception("Utility::invalid layer ID");
           }
         }
       }
     } else {
       // Count layers by binning stub distance from beam line.
       for (const Stub& stub : assocStubs_) {
         if ((!onlyPS) || stub.psModule()) {  // Consider only stubs in PS modules if that option specified.
           int layerID = (int)((stub.r() - trackerInnerRadius) / layerIDfromRadiusBin);
           if (layerID >= 0 && layerID < maxLayerID) {
             foundLayers[layerID] = true;
           } else {
             throw cms::Exception("Utility::invalid layer ID");
           }
         }
       }
     }
 
     unsigned int ncount = 0;
     for (const bool& found : foundLayers) {
       if (found)
         ncount++;
     }
 
     return ncount;
   }

void l1tVertexFinder::TP::fillUse ( )

private

Definition at line 99 of file TP.cc.

References edm::Ptr< T >::get(), settings_, l1tVertexFinder::AnalysisSettings::tpsUse(), trackingParticle_, and use_.

Referenced by TP().

                    {
     // Use looser cuts here those those used for tracking efficiency measurement.
     // Keep only those TP that have a chance (allowing for finite track resolution) of being reconstructed as L1 tracks. L1 tracks not matching these TP will be defined as fake.
     use_ = settings_->tpsUse()(trackingParticle_.get());
   }

void l1tVertexFinder::TP::fillUseForAlgEff ( )

private

Definition at line 114 of file TP.cc.

References countLayers(), l1tVertexFinder::AnalysisSettings::genMinStubLayers(), settings_, useForAlgEff_, and useForEff_.

Referenced by setMatchingStubs().

                             {
     useForAlgEff_ = false;
     if (useForEff_) {
       useForAlgEff_ = (countLayers() >= settings_->genMinStubLayers());
     }
   }

void l1tVertexFinder::TP::fillUseForEff ( )

private

Definition at line 106 of file TP.cc.

References edm::Ptr< T >::get(), settings_, l1tVertexFinder::AnalysisSettings::tpsUseForEff(), trackingParticle_, use_, and useForEff_.

Referenced by TP().

                          {
     useForEff_ = false;
     if (use_) {
       useForEff_ = settings_->tpsUseForEff()(trackingParticle_.get());
     }
   }

void l1tVertexFinder::TP::fillUseForVertexReco ( )

private

Definition at line 87 of file TP.cc.

References countLayers(), l1tVertexFinder::AnalysisSettings::genMinStubLayers(), edm::Ptr< T >::get(), settings_, l1tVertexFinder::AnalysisSettings::tpsUseForVtxReco(), trackingParticle_, use_, and useForVertexReco_.

Referenced by setMatchingStubs().

                                 {
     useForVertexReco_ = false;
     if (use_) {
       useForVertexReco_ = settings_->tpsUseForVtxReco()(trackingParticle_.get());
     }
 
     if (useForVertexReco_) {
       useForVertexReco_ = (countLayers() >= settings_->genMinStubLayers() and countLayers(true) >= 2);
     }
   }

const TrackingParticlePtr l1tVertexFinder::TP::getTrackingParticle ( ) const

inline

Definition at line 40 of file TP.h.

References trackingParticle_.

40 { return trackingParticle_; }

l1tVertexFinder::TP::trackingParticle_

TrackingParticlePtr trackingParticle_

Definition: TP.h:63

unsigned int l1tVertexFinder::TP::numAssocStubs ( ) const

inline

Definition at line 44 of file TP.h.

References assocStubs_.

44 { return assocStubs_.size(); }

l1tVertexFinder::TP::assocStubs_

std::vector< Stub > assocStubs_

Definition: TP.h:73

const TrackingParticlePtr l1tVertexFinder::TP::operator-> ( ) const

inline

Definition at line 46 of file TP.h.

References trackingParticle_.

46 { return trackingParticle_; }

l1tVertexFinder::TP::trackingParticle_

TrackingParticlePtr trackingParticle_

Definition: TP.h:63

bool l1tVertexFinder::TP::operator== ( const TP & rhs ) const

inline

Definition at line 24 of file TP.h.

References assocStubs_, inTimeBx_, nLayersWithStubs_, physicsCollision_, settings_, trackingParticle_, use_, useForAlgEff_, useForEff_, and useForVertexReco_.

                                          {
       return (trackingParticle_ == rhs.trackingParticle_ && settings_ == rhs.settings_ && inTimeBx_ == rhs.inTimeBx_ &&
               physicsCollision_ == rhs.physicsCollision_ && use_ == rhs.use_ && useForEff_ == rhs.useForEff_ &&
               useForAlgEff_ == rhs.useForAlgEff_ && useForVertexReco_ == rhs.useForVertexReco_ &&
               nLayersWithStubs_ == rhs.nLayersWithStubs_ && assocStubs_ == rhs.assocStubs_);
     }

bool l1tVertexFinder::TP::physicsCollision ( ) const

inline

Definition at line 42 of file TP.h.

References physicsCollision_.

Referenced by l1tVertexFinder::InputData::InputData().

42 { return physicsCollision_; }

l1tVertexFinder::TP::physicsCollision_

bool physicsCollision_

Definition: TP.h:67

void l1tVertexFinder::TP::setMatchingStubs ( const std::vector< Stub > & vMatchingStubs )

Definition at line 27 of file TP.cc.

References assocStubs_, countLayers(), fillUseForAlgEff(), fillUseForVertexReco(), and nLayersWithStubs_.

                                                                  {
     assocStubs_ = vMatchingStubs;
 
     this->fillUseForAlgEff();  // Fill useForAlgEff_ flag.
     this->fillUseForVertexReco();
     // Calculate number of tracker layers this TP has stubs in.
     nLayersWithStubs_ = countLayers();
   }