Inheritance diagram for PFRecoTauDiscriminationByHPSSelection:

Classes
struct	DecayModeCuts

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

	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)=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::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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_

double	minPt_

TauFunc	signalConeFun_

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::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

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

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::InputTag	TauProducer_

Detailed Description

Definition at line 19 of file PFRecoTauDiscriminationByHPSSelection.cc.

Member Typedef Documentation

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

private

Definition at line 44 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 43 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 42 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 27 of file PFRecoTauDiscriminationByHPSSelection.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 52 of file PFRecoTauDiscriminationByHPSSelection.cc.

References PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, hpstanc_transforms::cuts, decayModeCuts_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), matchingCone_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxPi0Mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minPi0Mass_, minPt_, and AlCaHLTBitMon_QueryRunRegistry::string.

   : PFTauDiscriminationProducerBase(pset),
     signalConeFun_(pset.getParameter<std::string>("coneSizeFormula")) 
 {
   // 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 &dm, decayModes) {
     // The mass window(s)
     DecayModeCuts cuts;
     cuts.minMass_ = dm.getParameter<double>("minMass");
     cuts.maxMass_ = new TauFunc(dm.getParameter<std::string>("maxMass"));
     if (dm.exists("minPi0Mass")) {
       cuts.minPi0Mass_ = dm.getParameter<double>("minPi0Mass");
       cuts.maxPi0Mass_ = dm.getParameter<double>("maxPi0Mass");
     } else {
       cuts.minPi0Mass_ = -1.e3;
       cuts.maxPi0Mass_ = 1.e9;
     }
     if (dm.exists("assumeStripMass")) {
       cuts.assumeStripMass_ = dm.getParameter<double>("assumeStripMass");
     } else {
       cuts.assumeStripMass_ = -1.0;
     }
     decayModeCuts_.insert(std::make_pair(
             // The decay mode as a key
             std::make_pair(
                 dm.getParameter<uint32_t>("nCharged"),
                 dm.getParameter<uint32_t>("nPiZeros")),
             cuts
           ));
   }
 }

PFRecoTauDiscriminationByHPSSelection::~PFRecoTauDiscriminationByHPSSelection ( )

Definition at line 89 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 )

Definition at line 98 of file PFRecoTauDiscriminationByHPSSelection.cc.

References PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, decayModeCuts_, deltaR(), matchingCone_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxPi0Mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minPi0Mass_, minPt_, reco::LeafCandidate::p4(), and signalConeFun_.

 {
   //std::cout << "<PFRecoTauDiscriminationByHPSSelection::discriminate>:" << std::endl;
 
   // Check if we pass the min pt
   if (tau->pt() < minPt_)
     return 0.0;
 
   // See if we select this decay mode
   DecayModeCutMap::const_iterator massWindowIter =
       decayModeCuts_.find(std::make_pair(tau->signalPFChargedHadrCands().size(),
                                          tau->signalPiZeroCandidates().size()));
   // Check if decay mode is supported
   if (massWindowIter == decayModeCuts_.end()) {
     return 0.0;
   }
   const DecayModeCuts& massWindow = massWindowIter->second;
 
   math::XYZTLorentzVector tauP4 = tau->p4();
   //std::cout << "tau: Pt = " << tauP4.pt() << ", eta = " << tauP4.eta() << ", phi = " << tauP4.phi() << ", mass = " << tauP4.mass() << std::endl;
   // 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;
     }
   }
   //std::cout << "strips: Pt = " << stripsP4.pt() << ", eta = " << stripsP4.eta() << ", phi = " << stripsP4.phi() << ", mass = " << stripsP4.mass() << std::endl;
 
   // Check if tau fails mass cut
   double maxMass_value = (*massWindow.maxMass_)(*tau);
   if (tauP4.M() > maxMass_value || tauP4.M() < massWindow.minMass_) {
     return 0.0;
   }
 
   // Check if it fails the pi 0 IM cut
   if (stripsP4.M() > massWindow.maxPi0Mass_ ||
       stripsP4.M() < massWindow.minPi0Mass_) {
     return 0.0;
   }
 
   // Check if tau passes matching cone cut
   //std::cout << "dR(tau, jet) = " << deltaR(tauP4, tau->jetRef()->p4()) << std::endl;
   if (deltaR(tauP4, tau->jetRef()->p4()) > matchingCone_) {
     return 0.0;
   }
 
   // Check if tau passes cone cut
   double cone_size = signalConeFun_(*tau);
   // Check if any charged objects fail the signal cone cut
   BOOST_FOREACH(const reco::PFCandidateRef& cand,
                 tau->signalPFChargedHadrCands()) {
     //std::cout << "dR(tau, signalPFChargedHadr) = " << deltaR(cand->p4(), tauP4) << std::endl;
     if (deltaR(cand->p4(), tauP4) > cone_size)
       return 0.0;
   }
   // Now check the pizeros
   BOOST_FOREACH(const reco::RecoTauPiZero& cand,
                 tau->signalPiZeroCandidates()) {
     //std::cout << "dR(tau, signalPiZero) = " << deltaR(cand.p4(), tauP4) << std::endl;
     if (deltaR(cand.p4(), tauP4) > cone_size)
       return 0.0;
   }
 
   // Otherwise, we pass!
   return 1.0;
 }