Inheritance diagram for PFRecoTauDiscriminationByHPSSelection:

Classes
struct	DecayModeCuts

Public Member Functions
double	discriminate (const reco::PFTauRef &) const override

	PFRecoTauDiscriminationByHPSSelection (const edm::ParameterSet &)

	~PFRecoTauDiscriminationByHPSSelection ()

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual void	beginEvent (const edm::Event &evt, const edm::EventSetup &evtSetup)

virtual double	discriminate (const TauRef &tau) const =0

virtual void	endEvent (edm::Event &evt)

void	produce (edm::Event &, const edm::EventSetup &)

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef std::map< IntPair, DecayModeCuts >	DecayModeCutMap

typedef std::pair< double, double >	DoublePair

typedef std::pair< unsigned int, unsigned int >	IntPair

typedef StringObjectFunction< reco::PFTau >	TauFunc

Private Attributes
DecayModeCutMap	decayModeCuts_

double	matchingCone_

int	minPixelHits_

double	minPt_

bool	requireTauChargedHadronsToBeChargedPFCands_

int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd< TauCollection >	TauRefProd

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 21 of file PFRecoTauDiscriminationByHPSSelection.cc.

Member Typedef Documentation

typedef std::map<IntPair, DecayModeCuts> PFRecoTauDiscriminationByHPSSelection::DecayModeCutMap

private

Definition at line 51 of file PFRecoTauDiscriminationByHPSSelection.cc.

typedef std::pair<double, double> PFRecoTauDiscriminationByHPSSelection::DoublePair

private

Definition at line 50 of file PFRecoTauDiscriminationByHPSSelection.cc.

typedef std::pair<unsigned int, unsigned int> PFRecoTauDiscriminationByHPSSelection::IntPair

private

Definition at line 49 of file PFRecoTauDiscriminationByHPSSelection.cc.

typedef StringObjectFunction<reco::PFTau> PFRecoTauDiscriminationByHPSSelection::TauFunc

private

Definition at line 29 of file PFRecoTauDiscriminationByHPSSelection.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationByHPSSelection::PFRecoTauDiscriminationByHPSSelection ( const edm::ParameterSet & pset )

explicit

Definition at line 64 of file PFRecoTauDiscriminationByHPSSelection.cc.

   : PFTauDiscriminationProducerBase(pset)
 {
   // Get the matchign cut
   matchingCone_ = pset.getParameter<double>("matchingCone");
   minPt_ = pset.getParameter<double>("minTauPt");
   // Get the mass cuts for each decay mode
   typedef std::vector<edm::ParameterSet> VPSet;
   const VPSet& decayModes = pset.getParameter<VPSet>("decayModes");
   BOOST_FOREACH( const edm::ParameterSet &decayMode, decayModes ) {
     // The mass window(s)
     DecayModeCuts cuts;
     if ( decayMode.exists("nTracksMin") ) {
       cuts.nTracksMin_ = decayMode.getParameter<unsigned>("nTracksMin");
     } else {
       cuts.nTracksMin_ = 0;
     }
     if ( decayMode.exists("nChargedPFCandsMin") ) {
       cuts.nChargedPFCandsMin_ = decayMode.getParameter<unsigned>("nChargedPFCandsMin");
     } else {
       cuts.nChargedPFCandsMin_ = 0;
     }
     cuts.minMass_ = decayMode.getParameter<double>("minMass");
     cuts.maxMass_ = new TauFunc(decayMode.getParameter<std::string>("maxMass"));
     edm::ParameterSet applyBendCorrection = decayMode.getParameter<edm::ParameterSet>("applyBendCorrection");
     cuts.applyBendCorrection_eta_ = applyBendCorrection.getParameter<bool>("eta");
     cuts.applyBendCorrection_phi_ = applyBendCorrection.getParameter<bool>("phi");
     cuts.applyBendCorrection_mass_ = applyBendCorrection.getParameter<bool>("mass");
     if ( decayMode.exists("minPi0Mass") ) {
       cuts.minPi0Mass_ = decayMode.getParameter<double>("minPi0Mass");
       cuts.maxPi0Mass_ = decayMode.getParameter<double>("maxPi0Mass");
     } else {
       cuts.minPi0Mass_ = -1.e3;
       cuts.maxPi0Mass_ = 1.e9;
     }
     if ( decayMode.exists("assumeStripMass") ) {
       cuts.assumeStripMass_ = decayMode.getParameter<double>("assumeStripMass");
     } else {
       cuts.assumeStripMass_ = -1.0;
     }
     decayModeCuts_.insert(std::make_pair(
             // The decay mode as a key
             std::make_pair(
                 decayMode.getParameter<uint32_t>("nCharged"),
                 decayMode.getParameter<uint32_t>("nPiZeros")),
             cuts
           ));
   }
   requireTauChargedHadronsToBeChargedPFCands_ = pset.getParameter<bool>("requireTauChargedHadronsToBeChargedPFCands");
   minPixelHits_ = pset.getParameter<int>("minPixelHits");
   verbosity_ = pset.exists("verbosity") ?
     pset.getParameter<int>("verbosity") : 0;
   
 
 }

PFRecoTauDiscriminationByHPSSelection::~PFRecoTauDiscriminationByHPSSelection ( )

Definition at line 120 of file PFRecoTauDiscriminationByHPSSelection.cc.

References decayModeCuts_.

 {
   for ( DecayModeCutMap::iterator it = decayModeCuts_.begin();
     it != decayModeCuts_.end(); ++it ) {
     delete it->second.maxMass_;
   }
 }

Member Function Documentation

double PFRecoTauDiscriminationByHPSSelection::discriminate ( const reco::PFTauRef & tau ) const

override

Definition at line 129 of file PFRecoTauDiscriminationByHPSSelection.cc.

 {
   if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << "<PFRecoTauDiscriminationByHPSSelection::discriminate>:" ;
     edm::LogPrint("PFTauByHPSSelect") << " nCharged = " << tau->signalTauChargedHadronCandidates().size() ;
     edm::LogPrint("PFTauByHPSSelect") << " nPiZeros = " << tau->signalPiZeroCandidates().size() ;
   }
 
   // Check if we pass the min pt
   if ( tau->pt() < minPt_ ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails minPt cut." ;
     }
     return 0.0;
   }
 
   // See if we select this decay mode
   DecayModeCutMap::const_iterator massWindowIter =
       decayModeCuts_.find(std::make_pair(tau->signalTauChargedHadronCandidates().size(),
                                          tau->signalPiZeroCandidates().size()));
   // Check if decay mode is supported
   if ( massWindowIter == decayModeCuts_.end() ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails mass-window definition requirement." ;
     }
     return 0.0;
   }
   const DecayModeCuts& massWindow = massWindowIter->second;
 
   if ( massWindow.nTracksMin_ > 0 ) {
     unsigned int nTracks = 0;
     const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
     for ( std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
       chargedHadron != chargedHadrons.end(); ++chargedHadron ) {
       if ( chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate) || chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kTrack) ) {
     ++nTracks;
       }
     }
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << "nTracks = " << nTracks << " (min = " << massWindow.nTracksMin_ << ")" ;
     }
     if ( nTracks < massWindow.nTracksMin_ ) {
       if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " fails nTracks requirement for mass-window." ;
       }
       return 0.0;
     }
   }
   if ( massWindow.nChargedPFCandsMin_ > 0 ) {
     unsigned int nChargedPFCands = 0;
     const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
     for ( std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
       chargedHadron != chargedHadrons.end(); ++chargedHadron ) {
       if ( chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate) ) {
     ++nChargedPFCands;
       }
     }
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << "nChargedPFCands = " << nChargedPFCands << " (min = " << massWindow.nChargedPFCandsMin_ << ")" ;
     }
     if ( nChargedPFCands < massWindow.nChargedPFCandsMin_ ) {
       if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " fails nChargedPFCands requirement for mass-window." ;
       }
       return 0.0;
     }
   }
 
   math::XYZTLorentzVector tauP4 = tau->p4();
   if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << "tau: Pt = " << tauP4.pt() << ", eta = " << tauP4.eta() << ", phi = " << tauP4.phi() << ", mass = " << tauP4.mass() ;
   }
   // Find the total pizero p4
   reco::Candidate::LorentzVector stripsP4;
   BOOST_FOREACH(const reco::RecoTauPiZero& cand, 
       tau->signalPiZeroCandidates()){
     math::XYZTLorentzVector candP4 = cand.p4();
     stripsP4 += candP4;
   }
 
   // Apply strip mass assumption corrections
   if (massWindow.assumeStripMass_ >= 0) {
     BOOST_FOREACH(const reco::RecoTauPiZero& cand, 
         tau->signalPiZeroCandidates()){
       math::XYZTLorentzVector uncorrected = cand.p4();
       math::XYZTLorentzVector corrected = 
         applyMassConstraint(uncorrected, massWindow.assumeStripMass_);
       math::XYZTLorentzVector correction = corrected - uncorrected;
       tauP4 += correction;
       stripsP4 += correction;
     }
   }
   if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << "strips: Pt = " << stripsP4.pt() << ", eta = " << stripsP4.eta() << ", phi = " << stripsP4.phi() << ", mass = " << stripsP4.mass() ;
   }
 
   // Check if tau fails mass cut
   double maxMass_value = (*massWindow.maxMass_)(*tau);
   double bendCorrection_mass = ( massWindow.applyBendCorrection_mass_ ) ? tau->bendCorrMass() : 0.;
   if ( !((tauP4.M() - bendCorrection_mass) < maxMass_value && (tauP4.M() + bendCorrection_mass) > massWindow.minMass_) ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut." ;
     }
     return 0.0;
   }
   // CV: require that mass of charged tau decay products is always within specified mass window,
   //     irrespective of bendCorrection_mass
   reco::Candidate::LorentzVector tauP4_charged;
   const std::vector<reco::PFRecoTauChargedHadron>& signalChargedHadrons = tau->signalTauChargedHadronCandidates();
   for ( std::vector<reco::PFRecoTauChargedHadron>::const_iterator signalChargedHadron = signalChargedHadrons.begin();
     signalChargedHadron != signalChargedHadrons.end(); ++signalChargedHadron ) {
     tauP4_charged += signalChargedHadron->p4();
   }
   if ( !(tauP4_charged.mass() < maxMass_value) ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut." ;
     }
     return 0.0;
   }
   
   // Check if it fails the pi0 IM cut
   if ( stripsP4.M() > massWindow.maxPi0Mass_ ||
        stripsP4.M() < massWindow.minPi0Mass_ ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails strip mass-window cut." ;
     }
     return 0.0;
   }
 
   // Check if tau passes matching cone cut
   //edm::LogPrint("PFTauByHPSSelect") << "dR(tau, jet) = " << deltaR(tauP4, tau->jetRef()->p4()) ;
   if ( deltaR(tauP4, tau->jetRef()->p4()) > matchingCone_ ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails matching-cone cut." ;
     }
     return 0.0;
   }
   
   // Check if tau passes cone cut
   double cone_size = tau->signalConeSize();
   // Check if any charged objects fail the signal cone cut
   for (auto const& cand : tau->signalTauChargedHadronCandidates()) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << "dR(tau, signalPFChargedHadr) = " << deltaR(cand.p4(), tauP4) ;
     }
     if ( deltaR(cand.p4(), tauP4) > cone_size ) {
       if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for charged hadron(s)." ;
       }
       return 0.0;
     }
   }
   // Now check the pizeros
   for (auto const& cand : tau->signalPiZeroCandidates()) {
     double bendCorrection_eta = ( massWindow.applyBendCorrection_eta_ ) ? cand.bendCorrEta() : 0.;
     double dEta = std::max(0., fabs(cand.eta() - tauP4.eta()) - bendCorrection_eta);
     double bendCorrection_phi = ( massWindow.applyBendCorrection_phi_ ) ? cand.bendCorrPhi() : 0.;
     double dPhi = std::max(0., std::abs(reco::deltaPhi(cand.phi(), tauP4.phi())) - bendCorrection_phi);
     double dR2 = dEta*dEta + dPhi*dPhi;
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << "dR2(tau, signalPiZero) = " << dR2 ;
     }
     if ( dR2 > cone_size*cone_size ) {
       if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for strip(s)." ;
       }
       return 0.0;
     }
   }
 
   if ( requireTauChargedHadronsToBeChargedPFCands_ ) {
     BOOST_FOREACH(const reco::PFRecoTauChargedHadron& cand, tau->signalTauChargedHadronCandidates()) {
       if ( verbosity_ ) {
     std::string algo_string;
     if      ( cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate ) algo_string = "ChargedPFCandidate";
     else if ( cand.algo() == reco::PFRecoTauChargedHadron::kTrack              ) algo_string = "Track";
     else if ( cand.algo() == reco::PFRecoTauChargedHadron::kPFNeutralHadron    ) algo_string = "PFNeutralHadron";
     else                                                                         algo_string = "Undefined";
     edm::LogPrint("PFTauByHPSSelect") << "algo(signalPFChargedHadr) = " << algo_string ;
       }
       if ( !(cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate) ) {
     if ( verbosity_ ) {
       edm::LogPrint("PFTauByHPSSelect") << " fails cut on PFRecoTauChargedHadron algo." ;
     }
     return 0.0;
       }
     }
   }
 
   if ( minPixelHits_ > 0 ) {
     int numPixelHits = 0;
     const std::vector<reco::PFCandidatePtr>& chargedHadrCands = tau->signalPFChargedHadrCands();
     for ( std::vector<reco::PFCandidatePtr>::const_iterator chargedHadrCand = chargedHadrCands.begin();
       chargedHadrCand != chargedHadrCands.end(); ++chargedHadrCand ) {
       const reco::Track* track = 0;
       if ( (*chargedHadrCand)->trackRef().isNonnull() ) track = (*chargedHadrCand)->trackRef().get();
       else if ( (*chargedHadrCand)->gsfTrackRef().isNonnull() ) track = (*chargedHadrCand)->gsfTrackRef().get();
       if ( track ) {
     numPixelHits += track->hitPattern().numberOfValidPixelHits();
       }
     }
     if ( !(numPixelHits >= minPixelHits_) ) {
       if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " fails cut on sum of pixel hits." ;
       }
       return 0.0;
     }
   }
 
   // Otherwise, we pass!
   if ( verbosity_ ) {
     edm::LogPrint("PFTauByHPSSelect") << " passes all cuts." ;
   }
   return 1.0;
 }