#include <RecoTauQualityCuts.h>

Public Types
typedef boost::function< bool(const PFCandidate &)>	CandQCutFunc

typedef std::vector< CandQCutFunc >	CandQCutFuncCollection

typedef std::map < PFCandidate::ParticleType, CandQCutFuncCollection >	CandQCutFuncMap

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

typedef std::vector < TrackQCutFunc >	TrackQCutFuncCollection

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

template<typename PFCandRefType >
bool	filterCandRef (const PFCandRefType &cand) const
	Filter a PFCandidate 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 PFCandidates. More...

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::TrackRef &leadTrack) const
	Update the leading track. More...

void	setLeadTrack (const reco::PFCandidate &leadCand) const

void	setLeadTrack (const reco::PFCandidateRef &leadCand) const

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

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

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

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

template<typename T >
bool	filterTrack_ (const T &trackRef) const

Private Attributes
bool	checkHitPattern_

bool	checkPV_

reco::TrackBaseRef	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

typedef boost::function<bool (const PFCandidate&)> reco::tau::RecoTauQualityCuts::CandQCutFunc

Definition at line 40 of file RecoTauQualityCuts.h.

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

Definition at line 41 of file RecoTauQualityCuts.h.

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

Definition at line 42 of file RecoTauQualityCuts.h.

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

Definition at line 38 of file RecoTauQualityCuts.h.

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

Definition at line 39 of file RecoTauQualityCuts.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 223 of file RecoTauQualityCuts.cc.

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

 {
   // 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();
 
   BOOST_FOREACH(const std::string& 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.size() ) {
     std::string unParsedOptions;
     bool thereIsABadParameter = false;
     BOOST_FOREACH( const std::string& 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;
   }
 }

Member Function Documentation

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

Filter a single PFCandidate.

Definition at line 410 of file RecoTauQualityCuts.cc.

References filterCandByType(), filterTrack_(), reco::PFCandidate::gsfTrackRef(), query::result, and reco::PFCandidate::trackRef().

Referenced by filterCandRef().

 {
   auto trackRef = cand.trackRef();
   bool result = true;
   if(trackRef.isNonnull()) {
     result = filterTrack_(trackRef);
   }
   else {
     auto gsfTrackRef = cand.gsfTrackRef();
     if(gsfTrackRef.isNonnull()) {
       result = filterTrack_(gsfTrackRef);
     }
   }
   if(result)
     result = filterCandByType(cand);
   return result;
 }

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

private

Definition at line 391 of file RecoTauQualityCuts.cc.

References reco::PFCandidate::e, filterGammaCand(), filterNeutralHadronCand(), reco::PFCandidate::gamma, reco::PFCandidate::h, reco::PFCandidate::h0, reco::PFCandidate::mu, and reco::PFCandidate::particleId().

Referenced by filterCand().

                                                                            {
   switch(cand.particleId()) {
   case PFCandidate::gamma:
     return filterGammaCand(cand);
   case PFCandidate::h0:
     return filterNeutralHadronCand(cand);
   // We use the same qcuts for muons/electrons and charged hadrons.
   case PFCandidate::h:
   case PFCandidate::e:
   case PFCandidate::mu:
     // 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;
 }

template<typename PFCandRefType >

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

inline

Filter a PFCandidate held by a smart pointer or Ref.

Definition at line 77 of file RecoTauQualityCuts.h.

References filterCand().

Referenced by filterCandRefs().

77 { return filterCand(*cand); }

reco::tau::RecoTauQualityCuts::filterCand

bool filterCand(const reco::PFCandidate &cand) const

Filter a single PFCandidate.

Definition: RecoTauQualityCuts.cc:410

template<typename Coll >

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

inline

Filter a ref vector of PFCandidates.

Definition at line 81 of file RecoTauQualityCuts.h.

References filterCandRef(), and convertSQLitetoXML_cfg::output.

Referenced by reco::tau::RecoTauVertexAssociator::getLeadTrack(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), reco::tau::RecoTauPiZeroTrivialPlugin::operator()(), reco::tau::RecoTauPiZeroCombinatoricPlugin::operator()(), reco::tau::RecoTauBuilderConePlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), and reco::tau::RecoTauPiZeroStripPlugin2::operator()().

   {
     Coll output;
     BOOST_FOREACH( const typename Coll::value_type cand, refcoll ) {
       if ( filterCandRef(cand)^invert ) output.push_back(cand);
     }
     return output;
   }

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

private

Definition at line 381 of file RecoTauQualityCuts.cc.

References reco::LeafCandidate::et(), and minGammaEt_.

Referenced by filterCandByType().

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

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

private

Definition at line 386 of file RecoTauQualityCuts.cc.

References reco::LeafCandidate::et(), and minNeutralHadronEt_.

Referenced by filterCandByType().

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

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

Filter a single Track.

Definition at line 335 of file RecoTauQualityCuts.cc.

References filterTrack_().

Referenced by filterTracks(), and reco::tau::PFRecoTauChargedHadronFromTrackPlugin::operator()().

 {
   return filterTrack_(track);
 }

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

Definition at line 340 of file RecoTauQualityCuts.cc.

References filterTrack_().

 {
   return filterTrack_(track);
 }

template<typename T >

bool reco::tau::RecoTauQualityCuts::filterTrack_ ( const T & trackRef ) const

private

Definition at line 346 of file RecoTauQualityCuts.cc.

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

Referenced by filterCand(), and filterTrack().

 {
   const Track *track = trackRef.get();
   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_.isNull()) {
       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;
   }
   if(minTrackVertexWeight_ > -1.0 && !(pv_->trackWeight(convertRef(trackRef)) >= minTrackVertexWeight_)) return false;
 
   return true;
 }

template<typename Coll >

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

inline

Filter a collection of Tracks.

Definition at line 63 of file RecoTauQualityCuts.h.

References filterTrack(), and convertSQLitetoXML_cfg::output.

   {
     Coll output;
     BOOST_FOREACH( const typename Coll::value_type track, coll ) {
       if ( filterTrack(track)^invert ) output.push_back(track);
     }
     return output;
   }

void reco::tau::RecoTauQualityCuts::setLeadTrack ( const reco::TrackRef & leadTrack ) const

Update the leading track.

Definition at line 428 of file RecoTauQualityCuts.cc.

References leadTrack_.

 {
   leadTrack_ = reco::TrackBaseRef(leadTrack);
 }

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

Definition at line 433 of file RecoTauQualityCuts.cc.

References leadTrack_.

 {
   leadTrack_ = getTrackRef(leadCand);
 }

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

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

Definition at line 438 of file RecoTauQualityCuts.cc.

References edm::Ref< C, T, F >::isNonnull(), and leadTrack_.

 {
   if ( leadCand.isNonnull() ) {
     leadTrack_ = getTrackRef(*leadCand);
   } else {
     // Set null
     leadTrack_ = reco::TrackBaseRef();
   }
 }