#include <RecoTauQualityCuts.h>

Public Types
typedef std::function< bool(const Candidate &)>	CandQCutFunc

typedef std::vector< CandQCutFunc >	CandQCutFuncCollection

typedef std::map< int, CandQCutFuncCollection >	CandQCutFuncMap

typedef std::function< bool(const TrackBaseRef &)>	TrackQCutFunc

typedef std::vector< TrackQCutFunc >	TrackQCutFuncCollection

Public Member Functions
bool	filterCand (const reco::Candidate &cand) const
	Filter a single Candidate. More...

template<typename CandRefType >
bool	filterCandRef (const CandRefType &cand) const
	Filter a Candidate held by a smart pointer or Ref. More...

template<typename Coll >
Coll	filterCandRefs (const Coll &refcoll, bool invert=false) const
	Filter a ref vector of Candidates. More...

bool	filterChargedCand (const reco::Candidate &cand) const
	or a single charged candidate More...

bool	filterTrack (const reco::Track &track) const

bool	filterTrack (const reco::TrackBaseRef &track) const
	Filter a single Track. More...

bool	filterTrack (const reco::TrackRef &track) const

template<typename Coll >
Coll	filterTracks (const Coll &coll, bool invert=false) const
	Filter a collection of Tracks. More...

	RecoTauQualityCuts (const edm::ParameterSet &qcuts)

void	setLeadTrack (const reco::Candidate &leadCand)

void	setLeadTrack (const reco::CandidateRef &leadCand)

void	setLeadTrack (const reco::Track &leadTrack)
	Update the leading track. More...

void	setPV (const reco::VertexRef &vtx)
	Update the primary vertex. More...

Private Member Functions
bool	filterCandByType (const reco::Candidate &cand) const

bool	filterGammaCand (const reco::Candidate &cand) const

bool	filterNeutralHadronCand (const reco::Candidate &cand) const

bool	filterTrack_ (const reco::Track *track) const

Private Attributes
bool	checkHitPattern_

bool	checkPV_

const reco::Track *	leadTrack_

double	maxDeltaZ_

double	maxDeltaZToLeadTrack_

double	maxTrackChi2_

double	maxTransverseImpactParameter_

double	minGammaEt_

double	minNeutralHadronEt_

int	minTrackHits_

int	minTrackPixelHits_

double	minTrackPt_

double	minTrackVertexWeight_

reco::VertexRef	pv_

Detailed Description

Definition at line 34 of file RecoTauQualityCuts.h.

Member Typedef Documentation

◆ CandQCutFunc

typedef std::function<bool(const Candidate&)> reco::tau::RecoTauQualityCuts::CandQCutFunc

Definition at line 39 of file RecoTauQualityCuts.h.

◆ CandQCutFuncCollection

typedef std::vector<CandQCutFunc> reco::tau::RecoTauQualityCuts::CandQCutFuncCollection

Definition at line 40 of file RecoTauQualityCuts.h.

◆ CandQCutFuncMap

typedef std::map<int, CandQCutFuncCollection> reco::tau::RecoTauQualityCuts::CandQCutFuncMap

Definition at line 41 of file RecoTauQualityCuts.h.

◆ TrackQCutFunc

typedef std::function<bool(const TrackBaseRef&)> reco::tau::RecoTauQualityCuts::TrackQCutFunc

Definition at line 37 of file RecoTauQualityCuts.h.

◆ TrackQCutFuncCollection

typedef std::vector<TrackQCutFunc> reco::tau::RecoTauQualityCuts::TrackQCutFuncCollection

Definition at line 38 of file RecoTauQualityCuts.h.

Constructor & Destructor Documentation

◆ RecoTauQualityCuts()

reco::tau::RecoTauQualityCuts::RecoTauQualityCuts ( const edm::ParameterSet & qcuts )

explicit

Definition at line 296 of file RecoTauQualityCuts.cc.

                                                                      {
     // Setup all of our predicates
     CandQCutFuncCollection chargedHadronCuts;
     CandQCutFuncCollection gammaCuts;
     CandQCutFuncCollection neutralHadronCuts;
  
     // Make sure there are no extra passed options
     std::set<std::string> passedOptionSet;
     std::vector<std::string> passedOptions = qcuts.getParameterNames();
  
     for (auto const& option : passedOptions) {
       passedOptionSet.insert(option);
     }
  
     unsigned int nCuts = 0;
     auto getDouble = [&qcuts, &passedOptionSet, &nCuts](const std::string& name) {
       if (qcuts.exists(name)) {
         ++nCuts;
         passedOptionSet.erase(name);
         return qcuts.getParameter<double>(name);
       }
       return -1.0;
     };
     auto getUint = [&qcuts, &passedOptionSet, &nCuts](const std::string& name) -> unsigned int {
       if (qcuts.exists(name)) {
         ++nCuts;
         passedOptionSet.erase(name);
         return qcuts.getParameter<unsigned int>(name);
       }
       return 0;
     };
  
     // Build all the QCuts for tracks
     minTrackPt_ = getDouble("minTrackPt");
     maxTrackChi2_ = getDouble("maxTrackChi2");
     minTrackPixelHits_ = getUint("minTrackPixelHits");
     minTrackHits_ = getUint("minTrackHits");
     maxTransverseImpactParameter_ = getDouble("maxTransverseImpactParameter");
     maxDeltaZ_ = getDouble("maxDeltaZ");
     maxDeltaZToLeadTrack_ = getDouble("maxDeltaZToLeadTrack");
     // Require tracks to contribute a minimum weight to the associated vertex.
     minTrackVertexWeight_ = getDouble("minTrackVertexWeight");
  
     // Use bit-wise & to avoid conditional code
     checkHitPattern_ = (minTrackHits_ > 0) || (minTrackPixelHits_ > 0);
     checkPV_ = (maxTransverseImpactParameter_ >= 0) || (maxDeltaZ_ >= 0) || (maxDeltaZToLeadTrack_ >= 0) ||
                (minTrackVertexWeight_ >= 0);
  
     // Build the QCuts for gammas
     minGammaEt_ = getDouble("minGammaEt");
  
     // Build QCuts for netural hadrons
     minNeutralHadronEt_ = getDouble("minNeutralHadronEt");
  
     // Check if there are any remaining unparsed QCuts
     if (!passedOptionSet.empty()) {
       std::string unParsedOptions;
       bool thereIsABadParameter = false;
       for (auto const& option : passedOptionSet) {
         // Workaround for HLT - TODO FIXME
         if (option == "useTracksInsteadOfPFHadrons") {
           // Crash if true - no one should have this option enabled.
           if (qcuts.getParameter<bool>("useTracksInsteadOfPFHadrons")) {
             throw cms::Exception("DontUseTracksInQcuts") << "The obsolete exception useTracksInsteadOfPFHadrons "
                                                          << "is set to true in the quality cut config." << std::endl;
           }
           continue;
         }
  
         // If we get to this point, there is a real unknown parameter
         thereIsABadParameter = true;
  
         unParsedOptions += option;
         unParsedOptions += "\n";
       }
       if (thereIsABadParameter) {
         throw cms::Exception("BadQualityCutConfig") << " The PSet passed to the RecoTauQualityCuts class had"
                                                     << " the following unrecognized options: " << std::endl
                                                     << unParsedOptions;
       }
     }
  
     // Make sure there are at least some quality cuts
     if (!nCuts) {
       throw cms::Exception("BadQualityCutConfig") << " No options were passed to the quality cut class!" << std::endl;
     }
   }

References checkHitPattern_, checkPV_, Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), maxDeltaZ_, maxDeltaZToLeadTrack_, maxTrackChi2_, maxTransverseImpactParameter_, minGammaEt_, minNeutralHadronEt_, minTrackHits_, minTrackPixelHits_, minTrackPt_, minTrackVertexWeight_, Skims_PA_cff::name, fileinputsource_cfi::option, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Function Documentation

◆ filterCand()

bool reco::tau::RecoTauQualityCuts::filterCand ( const reco::Candidate & cand ) const

Filter a single Candidate.

Definition at line 529 of file RecoTauQualityCuts.cc.

                                                                      {
     auto trackRef = getTrackRef(cand);
     bool result = true;
  
     if (trackRef.isNonnull()) {
       result = filterTrack(trackRef);
     } else {
       auto gsfTrackRef = getGsfTrackRef(cand);
       if (gsfTrackRef.isNonnull())
         result = filterTrack(gsfTrackRef);
       else if (cand.charge() != 0) {
         result = filterChargedCand(cand);
       }
     }
  
     if (result)
       result = filterCandByType(cand);
  
     return result;
   }

References filterCandByType(), filterChargedCand(), filterTrack(), and mps_fire::result.

Referenced by filterCandRef().

◆ filterCandByType()

bool reco::tau::RecoTauQualityCuts::filterCandByType ( const reco::Candidate & cand ) const

private

Definition at line 510 of file RecoTauQualityCuts.cc.

                                                                            {
     switch (std::abs(cand.pdgId())) {
       case 22:
         return filterGammaCand(cand);
       case 130:
         return filterNeutralHadronCand(cand);
       // We use the same qcuts for muons/electrons and charged hadrons.
       case 211:
       case 11:
       case 13:
         // no cuts ATM (track cuts applied in filterCand)
         return true;
       // Return false if we dont' know how to deal with this particle type
       default:
         return false;
     };
     return false;
   }

References funct::abs(), filterGammaCand(), and filterNeutralHadronCand().

Referenced by filterCand().

◆ filterCandRef()

template<typename CandRefType >

bool reco::tau::RecoTauQualityCuts::filterCandRef ( const CandRefType & cand ) const

inline

Filter a Candidate held by a smart pointer or Ref.

Definition at line 79 of file RecoTauQualityCuts.h.

                                                         {
         return filterCand(*cand);
       }

References filterCand().

Referenced by filterCandRefs().

◆ filterCandRefs()

template<typename Coll >

Coll reco::tau::RecoTauQualityCuts::filterCandRefs	(	const Coll &	refcoll,
		bool	invert = `false`
	)		const

inline

Filter a ref vector of Candidates.

Definition at line 85 of file RecoTauQualityCuts.h.

                                                                           {
         Coll output;
         for (auto const& cand : refcoll) {
           if (filterCandRef(cand) ^ invert)
             output.push_back(cand);
         }
         return output;
       }

References filterCandRef(), l1tstage2_dqm_sourceclient-live_cfg::invert, and convertSQLitetoXML_cfg::output.

Referenced by reco::tau::RecoTauVertexAssociator::getLeadCand(), reco::tau::RecoTauPiZeroTrivialPlugin::operator()(), reco::tau::RecoTauPiZeroCombinatoricPlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), and reco::tau::RecoTauPiZeroStripPlugin2::operator()().

◆ filterChargedCand()

bool reco::tau::RecoTauQualityCuts::filterChargedCand ( const reco::Candidate & cand ) const

or a single charged candidate

Definition at line 454 of file RecoTauQualityCuts.cc.

                                                                             {
     if (cand.charge() == 0)
       return true;
     const pat::PackedCandidate* pCand = dynamic_cast<const pat::PackedCandidate*>(&cand);
     if (pCand == nullptr)
       return true;
  
     //Get track, it should be present for cands with pT(charged)>0.5GeV
     //and check track quality critera other than vertex weight
     auto track = getTrack(cand);
     if (track != nullptr) {
       if (!filterTrack(*track))
         return false;
     } else {  //Candidates without track (pT(charged)<0.5GeV): Can still check pT and calculate dxy and dz
       if (minTrackPt_ >= 0 && !(pCand->pt() > minTrackPt_))
         return false;
       if (checkPV_ && pv_.isNull()) {
         edm::LogError("QCutsNoPrimaryVertex") << "Primary vertex Ref in "
                                               << "RecoTauQualityCuts is invalid. - filterChargedCand";
         return false;
       }
  
       if (maxTransverseImpactParameter_ >= 0 &&
           !(std::fabs(pCand->dxy(pv_->position())) <= maxTransverseImpactParameter_))
         return false;
       if (maxDeltaZ_ >= 0 && !(std::fabs(pCand->dz(pv_->position())) <= maxDeltaZ_))
         return false;
       if (maxDeltaZToLeadTrack_ >= 0) {
         if (leadTrack_ == nullptr) {
           edm::LogError("QCutsNoValidLeadTrack") << "Lead track Ref in "
                                                  << "RecoTauQualityCuts is invalid. - filterChargedCand";
           return false;
         }
  
         if (!(std::fabs(pCand->dz(pv_->position()) - leadTrack_->dz(pv_->position())) <= maxDeltaZToLeadTrack_))
           return false;
       }
     }
     if (minTrackVertexWeight_ >= 0. && !(qcuts::minPackedCandVertexWeight(*pCand, &pv_, minTrackVertexWeight_)))
       return false;
  
     return true;
   }

References checkPV_, pat::PackedCandidate::dxy(), reco::TrackBase::dz(), pat::PackedCandidate::dz(), filterTrack(), getTrack(), edm::Ref< C, T, F >::isNull(), leadTrack_, maxDeltaZ_, maxDeltaZToLeadTrack_, maxTransverseImpactParameter_, reco::tau::qcuts::minPackedCandVertexWeight(), minTrackPt_, minTrackVertexWeight_, pat::PackedCandidate::pt(), pv_, and HLT_2018_cff::track.

Referenced by filterCand().

◆ filterGammaCand()

bool reco::tau::RecoTauQualityCuts::filterGammaCand ( const reco::Candidate & cand ) const

private

Definition at line 498 of file RecoTauQualityCuts.cc.

                                                                           {
     if (minGammaEt_ >= 0 && !(cand.et() > minGammaEt_))
       return false;
     return true;
   }

References minGammaEt_.

Referenced by filterCandByType().

◆ filterNeutralHadronCand()

bool reco::tau::RecoTauQualityCuts::filterNeutralHadronCand ( const reco::Candidate & cand ) const

private

Definition at line 504 of file RecoTauQualityCuts.cc.

                                                                                   {
     if (minNeutralHadronEt_ >= 0 && !(cand.et() > minNeutralHadronEt_))
       return false;
     return true;
   }

References minNeutralHadronEt_.

Referenced by filterCandByType().

◆ filterTrack() [1/3]

bool reco::tau::RecoTauQualityCuts::filterTrack ( const reco::Track & track ) const

Definition at line 415 of file RecoTauQualityCuts.cc.

415 { return filterTrack_(&track); }

References filterTrack_(), and HLT_2018_cff::track.

◆ filterTrack() [2/3]

bool reco::tau::RecoTauQualityCuts::filterTrack ( const reco::TrackBaseRef & track ) const

Filter a single Track.

Definition at line 399 of file RecoTauQualityCuts.cc.

                                                                           {
     if (!filterTrack_(track.get()))
       return false;
     if (minTrackVertexWeight_ >= 0. && !(pv_->trackWeight(convertRef(track)) >= minTrackVertexWeight_))
       return false;
     return true;
   }

References filterTrack_(), minTrackVertexWeight_, pv_, and HLT_2018_cff::track.

Referenced by filterCand(), filterChargedCand(), and filterTracks().

◆ filterTrack() [3/3]

bool reco::tau::RecoTauQualityCuts::filterTrack ( const reco::TrackRef & track ) const

Definition at line 407 of file RecoTauQualityCuts.cc.

                                                                       {
     if (!filterTrack_(track.get()))
       return false;
     if (minTrackVertexWeight_ >= 0. && !(pv_->trackWeight(convertRef(track)) >= minTrackVertexWeight_))
       return false;
     return true;
   }

References filterTrack_(), minTrackVertexWeight_, pv_, and HLT_2018_cff::track.

◆ filterTrack_()

bool reco::tau::RecoTauQualityCuts::filterTrack_ ( const reco::Track * track ) const

private

Definition at line 417 of file RecoTauQualityCuts.cc.

                                                                     {
     if (minTrackPt_ >= 0 && !(track->pt() > minTrackPt_))
       return false;
     if (maxTrackChi2_ >= 0 && !(track->normalizedChi2() <= maxTrackChi2_))
       return false;
     if (checkHitPattern_) {
       const reco::HitPattern& hitPattern = track->hitPattern();
       if (minTrackPixelHits_ > 0 && !(hitPattern.numberOfValidPixelHits() >= minTrackPixelHits_))
         return false;
       if (minTrackHits_ > 0 && !(hitPattern.numberOfValidHits() >= minTrackHits_))
         return false;
     }
     if (checkPV_ && pv_.isNull()) {
       edm::LogError("QCutsNoPrimaryVertex") << "Primary vertex Ref in "
                                             << "RecoTauQualityCuts is invalid. - filterTrack";
       return false;
     }
  
     if (maxTransverseImpactParameter_ >= 0 &&
         !(std::fabs(track->dxy(pv_->position())) <= maxTransverseImpactParameter_))
       return false;
     if (maxDeltaZ_ >= 0 && !(std::fabs(track->dz(pv_->position())) <= maxDeltaZ_))
       return false;
     if (maxDeltaZToLeadTrack_ >= 0) {
       if (!leadTrack_) {
         edm::LogError("QCutsNoValidLeadTrack") << "Lead track Ref in "
                                                << "RecoTauQualityCuts is invalid. - filterTrack";
         return false;
       }
  
       if (!(std::fabs(track->dz(pv_->position()) - leadTrack_->dz(pv_->position())) <= maxDeltaZToLeadTrack_))
         return false;
     }
  
     return true;
   }

References checkHitPattern_, checkPV_, reco::TrackBase::dz(), edm::Ref< C, T, F >::isNull(), leadTrack_, maxDeltaZ_, maxDeltaZToLeadTrack_, maxTrackChi2_, maxTransverseImpactParameter_, minTrackHits_, minTrackPixelHits_, minTrackPt_, reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), pv_, and HLT_2018_cff::track.

Referenced by filterTrack().

◆ filterTracks()

template<typename Coll >

Coll reco::tau::RecoTauQualityCuts::filterTracks	(	const Coll &	coll,
		bool	invert = `false`
	)		const

inline

Filter a collection of Tracks.

Definition at line 65 of file RecoTauQualityCuts.h.

                                                                      {
         Coll output;
         for (auto const& track : coll) {
           if (filterTrack(track) ^ invert)
             output.push_back(track);
         }
         return output;
       }

References filterTrack(), l1tstage2_dqm_sourceclient-live_cfg::invert, convertSQLitetoXML_cfg::output, and HLT_2018_cff::track.

◆ setLeadTrack() [1/3]

void reco::tau::RecoTauQualityCuts::setLeadTrack ( const reco::Candidate & leadCand )

Definition at line 552 of file RecoTauQualityCuts.cc.

552 { leadTrack_ = getTrack(leadCand); }

References getTrack(), reco::tau::leadCand(), and leadTrack_.

◆ setLeadTrack() [2/3]

void reco::tau::RecoTauQualityCuts::setLeadTrack ( const reco::CandidateRef & leadCand )

Update the leading track (using reference) If null, this will set the lead track ref null.

Definition at line 554 of file RecoTauQualityCuts.cc.

                                                                         {
     if (leadCand.isNonnull()) {
       leadTrack_ = getTrack(*leadCand);
     } else {
       // Set null
       leadTrack_ = nullptr;
     }
   }