#include <TrackingParticleSelector.h>

Public Member Functions
bool	operator() (const TrackingParticle &tp) const
	Operator() performs the selection: e.g. if (tPSelector(tp)) {...}. More...

	TrackingParticleSelector ()

	TrackingParticleSelector (double ptMin, double ptMax, double minRapidity, double maxRapidity, double tip, double lip, int minHit, bool signalOnly, bool intimeOnly, bool chargedOnly, bool stableOnly, const std::vector< int > &pdgId=std::vector< int >(), bool invertRapidityCut=false, double minPhi=-3.2, double maxPhi=3.2)

Private Attributes
bool	chargedOnly_

bool	intimeOnly_

bool	invertRapidityCut_

double	lip_

float	maxRapidity_

float	meanPhi_

int	minHit_

float	minRapidity_

std::vector< int >	pdgId_

double	ptMax2_

double	ptMin2_

float	rangePhi_

bool	signalOnly_

bool	stableOnly_

double	tip2_

Detailed Description

Definition at line 16 of file TrackingParticleSelector.h.

Constructor & Destructor Documentation

TrackingParticleSelector::TrackingParticleSelector ( )

inline

Definition at line 18 of file TrackingParticleSelector.h.

Referenced by reco::modules::ParameterAdapter< TrackingParticleSelector >::make().

18 {}

TrackingParticleSelector::TrackingParticleSelector	(	double	ptMin,
		double	ptMax,
		double	minRapidity,
		double	maxRapidity,
		double	tip,
		double	lip,
		int	minHit,
		bool	signalOnly,
		bool	intimeOnly,
		bool	chargedOnly,
		bool	stableOnly,
		const std::vector< int > &	pdgId = `std::vector<int>()`,
		bool	invertRapidityCut = `false`,
		double	minPhi = `-3.2`,
		double	maxPhi = `3.2`
	)

inline

Definition at line 19 of file TrackingParticleSelector.h.

References Exception, M_PI, HLT_2018_cff::maxPhi, and HLT_2018_cff::minPhi.

       : ptMin2_(ptMin * ptMin),
         ptMax2_(ptMax * ptMax),
         minRapidity_(minRapidity),
         maxRapidity_(maxRapidity),
         meanPhi_((minPhi + maxPhi) / 2.),
         rangePhi_((maxPhi - minPhi) / 2.),
         tip2_(tip * tip),
         lip_(lip),
         minHit_(minHit),
         signalOnly_(signalOnly),
         intimeOnly_(intimeOnly),
         chargedOnly_(chargedOnly),
         stableOnly_(stableOnly),
         pdgId_(pdgId),
         invertRapidityCut_(invertRapidityCut) {
     if (minPhi >= maxPhi) {
       throw cms::Exception("Configuration")
           << "TrackingParticleSelector: minPhi (" << minPhi << ") must be smaller than maxPhi (" << maxPhi
           << "). The range is constructed from minPhi to maxPhi around their "
              "average.";
     }
     if (minPhi >= M_PI) {
       throw cms::Exception("Configuration") << "TrackingParticleSelector: minPhi (" << minPhi
                                             << ") must be smaller than PI. The range is constructed from minPhi "
                                                "to maxPhi around their average.";
     }
     if (maxPhi <= -M_PI) {
       throw cms::Exception("Configuration") << "TrackingParticleSelector: maxPhi (" << maxPhi
                                             << ") must be larger than -PI. The range is constructed from minPhi "
                                                "to maxPhi around their average.";
     }
   }

Member Function Documentation

bool TrackingParticleSelector::operator() ( const TrackingParticle & tp ) const

inline

Operator() performs the selection: e.g. if (tPSelector(tp)) {...}.

Definition at line 68 of file TrackingParticleSelector.h.

References funct::abs(), EncodedEventId::bunchCrossing(), TrackingParticle::charge(), chargedOnly_, SiPixelRawToDigiRegional_cfi::deltaPhi, PVValHelper::eta, EncodedEventId::event(), TrackingParticle::eventId(), TrackingParticle::genParticle_begin(), TrackingParticle::genParticle_end(), intimeOnly_, invertRapidityCut_, dqmiolumiharvest::j, lip_, maxRapidity_, meanPhi_, minHit_, minRapidity_, TrackingParticle::numberOfTrackerLayers(), AlCaHLTBitMon_ParallelJobs::p, TrackingParticle::p4(), EgammaValidation_cff::pdgid, TrackingParticle::pdgId(), pdgId_, HLT_2018_cff::pt2, ptMax2_, ptMin2_, rangePhi_, signalOnly_, stableOnly_, TrackingParticle::status(), tip2_, and TrackingParticle::vertex().

                                                     {
     // signal only means no PU particles
     if (signalOnly_ && !(tp.eventId().bunchCrossing() == 0 && tp.eventId().event() == 0))
       return false;
     // intime only means no OOT PU particles
     if (intimeOnly_ && !(tp.eventId().bunchCrossing() == 0))
       return false;
 
     auto pdgid = tp.pdgId();
     if (!pdgId_.empty()) {
       bool testId = false;
       for (auto id : pdgId_) {
         if (id == pdgid) {
           testId = true;
           break;
         }
       }
       if (!testId)
         return false;
     }
 
     if (chargedOnly_ && tp.charge() == 0)
       return false;  // select only if charge!=0
 
     // select only stable particles
     if (stableOnly_) {
       for (TrackingParticle::genp_iterator j = tp.genParticle_begin(); j != tp.genParticle_end(); ++j) {
         if (j->get() == nullptr || j->get()->status() != 1) {
           return false;
         }
       }
       // test for remaining unstabled due to lack of genparticle pointer
       if (tp.status() == -99 && (std::abs(pdgid) != 11 && std::abs(pdgid) != 13 && std::abs(pdgid) != 211 &&
                                  std::abs(pdgid) != 321 && std::abs(pdgid) != 2212 && std::abs(pdgid) != 3112 &&
                                  std::abs(pdgid) != 3222 && std::abs(pdgid) != 3312 && std::abs(pdgid) != 3334))
         return false;
     }
 
     auto etaOk = [&](const TrackingParticle &p) -> bool {
       float eta = etaFromXYZ(p.px(), p.py(), p.pz());
       if (!invertRapidityCut_)
         return (eta >= minRapidity_) && (eta <= maxRapidity_);
       else
         return (eta < minRapidity_ || eta > maxRapidity_);
     };
     auto phiOk = [&](const TrackingParticle &p) {
       float dphi = deltaPhi(atan2f(p.py(), p.px()), meanPhi_);
       return dphi >= -rangePhi_ && dphi <= rangePhi_;
     };
     auto ptOk = [&](const TrackingParticle &p) {
       double pt2 = tp.p4().perp2();
       return pt2 >= ptMin2_ && pt2 <= ptMax2_;
     };
     return (tp.numberOfTrackerLayers() >= minHit_ && ptOk(tp) && etaOk(tp) && phiOk(tp) &&
             std::abs(tp.vertex().z()) <= lip_ &&  // vertex last to avoid to load it if not striclty
                                                   // necessary...
             tp.vertex().perp2() <= tip2_);
   }