Inheritance diagram for reco::tau::RecoTauBuilderConePlugin:

Public Member Functions
return_type	operator() (const reco::PFJetRef &jet, const std::vector< reco::PFRecoTauChargedHadron > &chargedHadrons, const std::vector< RecoTauPiZero > &piZeros, const std::vector< PFCandidatePtr > &regionalExtras) const override

	RecoTauBuilderConePlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~RecoTauBuilderConePlugin () override

Public Member Functions inherited from reco::tau::RecoTauBuilderPlugin
void	beginEvent () override

const edm::Handle< PFCandidateCollection > &	getPFCands () const
	Hack to be able to convert Ptrs to Refs. More...

reco::VertexRef	primaryVertex (const reco::PFJetRef &jet) const
	Get primary vertex associated to this jet. More...

reco::VertexRef	primaryVertex (const reco::PFTau &tau, bool useJet=false) const
	Get primary vertex associated to this tau. More...

	RecoTauBuilderPlugin (const edm::ParameterSet &pset, edm::ConsumesCollector &&iC)

	~RecoTauBuilderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauEventHolderPlugin
const edm::Event *	evt () const

edm::Event *	evt ()

const edm::EventSetup *	evtSetup () const

	RecoTauEventHolderPlugin (const edm::ParameterSet &pset)

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

	~RecoTauEventHolderPlugin () override

Public Member Functions inherited from reco::tau::RecoTauNamedPlugin
const std::string &	name () const

	RecoTauNamedPlugin (const edm::ParameterSet &pset)

virtual	~RecoTauNamedPlugin ()

Private Types
typedef StringObjectFunction< reco::PFJet >	JetFunc

Private Member Functions
void	setTauQuantities (reco::PFTau &aTau, double minAbsPhotonSumPt_insideSignalCone=2.5, double minRelPhotonSumPt_insideSignalCone=0., double minAbsPhotonSumPt_outsideSignalCone=1.e+9, double minRelPhotonSumPt_outsideSignalCone=1.e+9) const

Additional Inherited Members
Public Types inherited from reco::tau::RecoTauBuilderPlugin
typedef boost::ptr_vector< reco::PFTau >	output_type

typedef std::auto_ptr< output_type >	return_type

Detailed Description

Definition at line 34 of file RecoTauBuilderConePlugin.cc.

Member Typedef Documentation

typedef StringObjectFunction<reco::PFJet> reco::tau::RecoTauBuilderConePlugin::JetFunc

private

Definition at line 51 of file RecoTauBuilderConePlugin.cc.

Constructor & Destructor Documentation

reco::tau::RecoTauBuilderConePlugin::RecoTauBuilderConePlugin	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &&	iC
	)

explicit

Definition at line 76 of file RecoTauBuilderConePlugin.cc.

                                                                                   :RecoTauBuilderPlugin(pset,std::move(iC)),
     qcuts_(pset.getParameterSet(
           "qualityCuts").getParameterSet("signalQualityCuts")),
     usePFLeptonsAsChargedHadrons_(pset.getParameter<bool>("usePFLeptons")),
     leadObjecPtThreshold_(pset.getParameter<double>("leadObjectPt")),
     matchingCone_(pset.getParameter<std::string>("matchingCone")),
     signalConeChargedHadrons_(pset.getParameter<std::string>(
             "signalConeChargedHadrons")),
     isoConeChargedHadrons_(
         pset.getParameter<std::string>("isoConeChargedHadrons")),
     signalConePiZeros_(
         pset.getParameter<std::string>("signalConePiZeros")),
     signalConeSizeToStore_(//MB: stored inside PFTau and used to compte photon-pt-out-of-signal-cone and DM hypothsis
     pset.getParameter<std::string>("signalConePiZeros")),
     isoConePiZeros_(
         pset.getParameter<std::string>("isoConePiZeros")),
     signalConeNeutralHadrons_(
         pset.getParameter<std::string>("signalConeNeutralHadrons")),
     isoConeNeutralHadrons_(
         pset.getParameter<std::string>("isoConeNeutralHadrons")), 
     maxSignalConeChargedHadrons_(
         pset.getParameter<int>("maxSignalConeChargedHadrons")),
     minAbsPhotonSumPt_insideSignalCone_(
         pset.getParameter<double>("minAbsPhotonSumPt_insideSignalCone")),
     minRelPhotonSumPt_insideSignalCone_(
     pset.getParameter<double>("minRelPhotonSumPt_insideSignalCone"))
 
 {}

reco::tau::RecoTauBuilderConePlugin::~RecoTauBuilderConePlugin ( )

inlineoverride

Definition at line 37 of file RecoTauBuilderConePlugin.cc.

References metsig::jet, and operator()().

37 {}

Member Function Documentation

RecoTauBuilderConePlugin::return_type reco::tau::RecoTauBuilderConePlugin::operator()	(	const reco::PFJetRef &	,
		const std::vector< reco::PFRecoTauChargedHadron > &	,
		const std::vector< RecoTauPiZero > &	,
		const std::vector< PFCandidatePtr > &
	)		const

overridevirtual

Construct one or more PFTaus from the a PFJet and its asscociated reconstructed PiZeros and regional extras i.e. objects in a 0.8 cone about the jet

Implements reco::tau::RecoTauBuilderPlugin.

Definition at line 187 of file RecoTauBuilderConePlugin.cc.

Referenced by ~RecoTauBuilderConePlugin().

                                                            {
   //std::cout << "<RecoTauBuilderConePlugin::operator()>:" << std::endl;
   //std::cout << " jet: Pt = " << jet->pt() << ", eta = " << jet->eta() << ", phi = " << jet->phi() << std::endl;
 
   // Get access to our cone tools
   using namespace cone;
   // Define output.  We only produce one tau per jet for the cone algo.
   output_type output;
 
   // Our tau builder - the true indicates to automatically copy gamma candidates
   // from the pizeros.
   RecoTauConstructor tau(jet, getPFCands(), true, 
              &signalConeSizeToStore_, 
              minAbsPhotonSumPt_insideSignalCone_, 
              minRelPhotonSumPt_insideSignalCone_);
   // Setup our quality cuts to use the current vertex (supplied by base class)
   qcuts_.setPV(primaryVertex(jet));
 
   typedef std::vector<PFCandidatePtr> PFCandPtrs;
 
   // Get the PF Charged hadrons + quality cuts
   PFCandPtrs pfchs;
   if (!usePFLeptonsAsChargedHadrons_) {
     pfchs = qcuts_.filterCandRefs(pfCandidates(*jet, reco::PFCandidate::h));
   } else {
     // Check if we want to include electrons in muons in "charged hadron"
     // collection.  This is the preferred behavior, as the PF lepton selections
     // are very loose.
     pfchs = qcuts_.filterCandRefs(pfChargedCands(*jet));
   }
 
   // CV: sort collection of PF Charged hadrons by descending Pt
   std::sort(pfchs.begin(), pfchs.end(), SortPFCandsDescendingPt());
 
   // Get the PF gammas
   PFCandPtrs pfGammas = qcuts_.filterCandRefs(
       pfCandidates(*jet, reco::PFCandidate::gamma));
   // Neutral hadrons
   PFCandPtrs pfnhs = qcuts_.filterCandRefs(
       pfCandidates(*jet, reco::PFCandidate::h0));
 
   // All the extra junk
   PFCandPtrs regionalJunk = qcuts_.filterCandRefs(regionalExtras);
 
   /***********************************************
    ******     Lead Candidate Finding    **********
    ***********************************************/
 
   // Define our matching cone and filters
   double matchingCone = matchingCone_(*jet);
   PFCandPtrDRFilter matchingConeFilter(jet->p4(), 0, matchingCone);
 
   // Find the maximum PFCharged hadron in the matching cone.  The call to
   // PFCandidates always a sorted list, so we can just take the first if it
   // if it exists.
   PFCandidatePtr leadPFCH;
   PFCandPtrs::iterator leadPFCH_iter =
       std::find_if(pfchs.begin(), pfchs.end(), matchingConeFilter);
 
   if (leadPFCH_iter != pfchs.end()) {
     leadPFCH = *leadPFCH_iter;
     // Set leading candidate
     tau.setleadPFChargedHadrCand(leadPFCH);
   } else {
     // If there is no leading charged candidate at all, return nothing - the
     // producer class that owns the plugin will build a null tau if desired.
     return output.release();
   }
 
   // Find the leading neutral candidate
   PFCandidatePtr leadPFGamma;
   PFCandPtrs::iterator leadPFGamma_iter =
       std::find_if(pfGammas.begin(), pfGammas.end(), matchingConeFilter);
 
   if (leadPFGamma_iter != pfGammas.end()) {
     leadPFGamma = *leadPFGamma_iter;
     // Set leading neutral candidate
     tau.setleadPFNeutralCand(leadPFGamma);
   }
 
   PFCandidatePtr leadPFCand;
   // Always use the leadPFCH if it is above our threshold
   if (leadPFCH.isNonnull() && leadPFCH->pt() > leadObjecPtThreshold_) {
     leadPFCand = leadPFCH;
   } else if (leadPFGamma.isNonnull() &&
              leadPFGamma->pt() > leadObjecPtThreshold_) {
     // Otherwise use the lead Gamma if it is above threshold
     leadPFCand = leadPFGamma;
   } else {
     // If both are too low PT, just take the charged one
     leadPFCand = leadPFCH;
   }
 
   tau.setleadPFCand(leadPFCand);
 
   // Our cone axis is defined about the lead charged hadron
   reco::Candidate::LorentzVector coneAxis = leadPFCH->p4();
 
   /***********************************************
    ******     Cone Construction         **********
    ***********************************************/
 
   // Define the signal and isolation cone sizes for this jet and build filters
   // to select elements in the given DeltaR regions
 
   PFCandPtrDRFilter signalConePFCHFilter(
       coneAxis, -0.1, signalConeChargedHadrons_(*jet));
   PFCandPtrDRFilter signalConePFNHFilter(
       coneAxis, -0.1, signalConeNeutralHadrons_(*jet));
   PiZeroDRFilter signalConePiZeroFilter(
       coneAxis, -0.1, signalConePiZeros_(*jet));
 
   PFCandPtrDRFilter isoConePFCHFilter(
       coneAxis, signalConeChargedHadrons_(*jet), isoConeChargedHadrons_(*jet));
   PFCandPtrDRFilter isoConePFGammaFilter(
       coneAxis, signalConePiZeros_(*jet), isoConePiZeros_(*jet));
   PFCandPtrDRFilter isoConePFNHFilter(
       coneAxis, signalConeNeutralHadrons_(*jet), isoConeNeutralHadrons_(*jet));
   PiZeroDRFilter isoConePiZeroFilter(
       coneAxis, signalConePiZeros_(*jet), isoConePiZeros_(*jet));
 
   // Additionally make predicates to select the different PF object types
   // of the regional junk objects to add to the iso cone.
   typedef xclean::PredicateAND<xclean::FilterPFCandByParticleId, PFCandPtrDRFilter> RegionalJunkConeAndIdFilter;
 
   xclean::FilterPFCandByParticleId pfchCandSelector(reco::PFCandidate::h);
   xclean::FilterPFCandByParticleId pfgammaCandSelector(reco::PFCandidate::gamma);
   xclean::FilterPFCandByParticleId pfnhCandSelector(reco::PFCandidate::h0);
 
   // Predicate to select the regional junk in the iso cone by PF id
   RegionalJunkConeAndIdFilter pfChargedJunk(
       pfchCandSelector, // select charged stuff from junk
       isoConePFCHFilter // only take those in iso cone
       );
 
   RegionalJunkConeAndIdFilter pfGammaJunk(
       pfgammaCandSelector, // select gammas from junk
       isoConePFGammaFilter // only take those in iso cone
       );
 
   RegionalJunkConeAndIdFilter pfNeutralJunk(
       pfnhCandSelector, // select neutral stuff from junk
       isoConePFNHFilter // select stuff in iso cone
       );
 
   // Build filter iterators select the signal charged stuff.
   PFCandPtrDRFilterIter signalPFCHCands_begin(
       signalConePFCHFilter, pfchs.begin(), pfchs.end());
   PFCandPtrDRFilterIter signalPFCHCands_end(
       signalConePFCHFilter, pfchs.end(), pfchs.end());
   PFCandPtrs signalPFCHs;
   int numSignalPFCHs = 0;
   PFCandPtrs isolationPFCHs;
   int numIsolationPFCHs = 0;
   for ( PFCandPtrDRFilterIter iter = signalPFCHCands_begin; iter != signalPFCHCands_end; ++iter ) {
     if ( numSignalPFCHs < maxSignalConeChargedHadrons_ || maxSignalConeChargedHadrons_ == -1 ) {
       //std::cout << "adding signalPFCH #" << numSignalPFCHs << ": Pt = " << (*iter)->pt() << ", eta = " << (*iter)->eta() << ", phi = " << (*iter)->phi() << std::endl;
       signalPFCHs.push_back(*iter);
       ++numSignalPFCHs;
     } else {
       //std::cout << "maxSignalConeChargedHadrons reached" 
       //      << " --> adding isolationPFCH #" << numIsolationPFCHs << ": Pt = " << (*iter)->pt() << ", eta = " << (*iter)->eta() << ", phi = " << (*iter)->phi() << std::endl;
       isolationPFCHs.push_back(*iter);
       ++numIsolationPFCHs;
     }
   }
   PFCandPtrs::const_iterator signalPFCHs_begin = signalPFCHs.begin();
   PFCandPtrs::const_iterator signalPFCHs_end = signalPFCHs.end();
 
   // Cross clean pi zero content using signal cone charged hadron constituents.
   xclean::CrossCleanPiZeros<PFCandPtrDRFilterIter> piZeroXCleaner(
       signalPFCHCands_begin, signalPFCHCands_end);
   std::vector<reco::RecoTauPiZero> cleanPiZeros = piZeroXCleaner(piZeros);
 
   // For the rest of the constituents, we need to filter any constituents that
   // are already contained in the pizeros (i.e. electrons)
   xclean::CrossCleanPtrs<PiZeroList::const_iterator> pfCandXCleaner(cleanPiZeros.begin(), cleanPiZeros.end());
 
   auto isolationPFCHCands_begin(
       boost::make_filter_iterator(
         xclean::makePredicateAND(isoConePFCHFilter, pfCandXCleaner),
     pfchs.begin(), pfchs.end()));
   auto isolationPFCHCands_end(
       boost::make_filter_iterator(
     xclean::makePredicateAND(isoConePFCHFilter, pfCandXCleaner),
     pfchs.end(), pfchs.end()));
   for ( auto iter = isolationPFCHCands_begin; iter != isolationPFCHCands_end; ++iter ) {
     //std::cout << "adding isolationPFCH #" << numIsolationPFCHs << ": Pt = " << (*iter)->pt() << ", eta = " << (*iter)->eta() << ", phi = " << (*iter)->phi() << std::endl;
     isolationPFCHs.push_back(*iter);
     ++numIsolationPFCHs;
   }
   PFCandPtrs::const_iterator isolationPFCHs_begin = isolationPFCHs.begin();
   PFCandPtrs::const_iterator isolationPFCHs_end = isolationPFCHs.end();
 
   // Build signal charged hadrons
   tau.addPFCands(RecoTauConstructor::kSignal,
                  RecoTauConstructor::kChargedHadron,
                  signalPFCHs_begin, signalPFCHs_end);
 
   tau.addPFCands(RecoTauConstructor::kSignal,
                  RecoTauConstructor::kNeutralHadron,
                  boost::make_filter_iterator(
                    xclean::makePredicateAND(signalConePFNHFilter, pfCandXCleaner),
                    pfnhs.begin(), pfnhs.end()),
                  boost::make_filter_iterator(
                    xclean::makePredicateAND(signalConePFNHFilter, pfCandXCleaner),
                    pfnhs.end(), pfnhs.end()));
 
   // Build signal PiZeros
   tau.addPiZeros(RecoTauConstructor::kSignal,
                  PiZeroDRFilterIter(signalConePiZeroFilter,
                                     cleanPiZeros.begin(), cleanPiZeros.end()),
                  PiZeroDRFilterIter(signalConePiZeroFilter,
                                     cleanPiZeros.end(), cleanPiZeros.end()));
 
   // Build isolation charged hadrons
   tau.addPFCands(RecoTauConstructor::kIsolation,
                  RecoTauConstructor::kChargedHadron,
          isolationPFCHs_begin, isolationPFCHs_end);
 
   // Add all the stuff in the isolation cone that wasn't in the jet constituents
   tau.addPFCands(RecoTauConstructor::kIsolation,
                  RecoTauConstructor::kChargedHadron,
                  boost::make_filter_iterator(
                    pfChargedJunk, regionalJunk.begin(), regionalJunk.end()),
                  boost::make_filter_iterator(
                    pfChargedJunk, regionalJunk.end(), regionalJunk.end())
       );
 
   // Build isolation neutral hadrons
   tau.addPFCands(RecoTauConstructor::kIsolation,
                  RecoTauConstructor::kNeutralHadron,
                  boost::make_filter_iterator(
                    xclean::makePredicateAND(isoConePFNHFilter, pfCandXCleaner),
                    pfnhs.begin(), pfnhs.end()),
                  boost::make_filter_iterator(
                    xclean::makePredicateAND(isoConePFNHFilter, pfCandXCleaner),
                    pfnhs.end(), pfnhs.end()));
 
   // Add regional stuff not in jet
   tau.addPFCands(RecoTauConstructor::kIsolation,
                  RecoTauConstructor::kNeutralHadron,
                  boost::make_filter_iterator(
                    pfNeutralJunk, regionalJunk.begin(), regionalJunk.end()),
                  boost::make_filter_iterator(
                    pfNeutralJunk, regionalJunk.end(), regionalJunk.end())
       );
 
   // Build isolation PiZeros
   tau.addPiZeros(RecoTauConstructor::kIsolation,
                  PiZeroDRFilterIter(isoConePiZeroFilter, cleanPiZeros.begin(),
                                     cleanPiZeros.end()),
                  PiZeroDRFilterIter(isoConePiZeroFilter, cleanPiZeros.end(),
                                     cleanPiZeros.end()));
 
   // Add regional stuff not in jet
   tau.addPFCands(RecoTauConstructor::kIsolation,
                  RecoTauConstructor::kGamma,
                  boost::make_filter_iterator(
                    pfGammaJunk, regionalJunk.begin(), regionalJunk.end()),
                  boost::make_filter_iterator(
                    pfGammaJunk, regionalJunk.end(), regionalJunk.end())
       );
 
   // Put our built tau in the output - 'false' indicates don't build the
   // leading candidates, we already did that explicitly above.
 
   std::auto_ptr<reco::PFTau> tauPtr = tau.get(false);
 
   // Set event vertex position for tau
   reco::VertexRef primaryVertexRef = primaryVertex(*tauPtr);
   if ( primaryVertexRef.isNonnull() )
     tauPtr->setVertex(primaryVertexRef->position());
 
   // Set missing tau quantities
   setTauQuantities(*tauPtr,
            minAbsPhotonSumPt_insideSignalCone_,
            minRelPhotonSumPt_insideSignalCone_
            );
 
   output.push_back(tauPtr);
   return output.release();
 }

void reco::tau::RecoTauBuilderConePlugin::setTauQuantities	(	reco::PFTau &	aTau,
		double	minAbsPhotonSumPt_insideSignalCone = `2.5`,
		double	minRelPhotonSumPt_insideSignalCone = `0.`,
		double	minAbsPhotonSumPt_outsideSignalCone = `1.e+9`,
		double	minRelPhotonSumPt_outsideSignalCone = `1.e+9`
	)		const

private

Definition at line 127 of file RecoTauBuilderConePlugin.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, reco::LeafCandidate::charge(), reco::deltaR(), symbols::dm, PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, edm::Ptr< T >::isNonnull(), reco::PFTau::kNull, reco::PFTau::kOneProngNPiZero, reco::PFTau::kRareDecayMode, reco::PFTau::leadPFChargedHadrCand(), RecoTauCombinatoricProducer_cfi::maxPiZeros, min(), hpstanc_transforms::nCharged, hpstanc_transforms::nPiZeros, reco::Candidate::p4(), reco::LeafCandidate::p4(), muons2muons_cfi::photon, reco::Candidate::pt(), reco::LeafCandidate::pt(), reco::LeafCandidate::setCharge(), reco::PFTau::setDecayMode(), reco::LeafCandidate::setPdgId(), reco::PFTau::signalConeSize(), reco::PFTau::signalPFChargedHadrCands(), and reco::PFTau::signalPiZeroCandidates().

Referenced by operator()().

                                                                           {
   //MB: Set tau quantities which are computed by RecoTauConstructor::get() 
   //    method with PFRecoTauChargedHadrons not used here
   
   // Set charge
   int charge = 0;
   int leadCharge = aTau.leadPFChargedHadrCand().isNonnull() ? aTau.leadPFChargedHadrCand()->charge() : 0;
   const std::vector<reco::PFCandidatePtr>& pfChs = aTau.signalPFChargedHadrCands();
   for(const reco::PFCandidatePtr& pfCh : pfChs){
     charge += pfCh->charge();
   }
   charge = charge==0 ? leadCharge : charge;
   aTau.setCharge(charge);
   
   // Set PDG id
   aTau.setPdgId(aTau.charge() < 0 ? 15 : -15); 
   
   // Set Decay Mode
   PFTau::hadronicDecayMode dm = PFTau::kNull; 
   unsigned int nPiZeros = 0;
   const std::vector<RecoTauPiZero>& piZeros = aTau.signalPiZeroCandidates();
   for(const RecoTauPiZero& piZero : piZeros) {
     double photonSumPt_insideSignalCone = 0.;
     double photonSumPt_outsideSignalCone = 0.;
     int numPhotons = piZero.numberOfDaughters();
     for(int idxPhoton = 0; idxPhoton < numPhotons; ++idxPhoton) {
       const reco::Candidate* photon = piZero.daughter(idxPhoton);
       double dR = deltaR(photon->p4(), aTau.p4());
       if(dR < aTau.signalConeSize() ){
     photonSumPt_insideSignalCone += photon->pt();
       } else {
     photonSumPt_outsideSignalCone += photon->pt();
       }
     }
     if( photonSumPt_insideSignalCone  > minAbsPhotonSumPt_insideSignalCone  || photonSumPt_insideSignalCone  > (minRelPhotonSumPt_insideSignalCone*aTau.pt())  ||
     photonSumPt_outsideSignalCone > minAbsPhotonSumPt_outsideSignalCone || photonSumPt_outsideSignalCone > (minRelPhotonSumPt_outsideSignalCone*aTau.pt()) ) ++nPiZeros;
   }
   // Find the maximum number of PiZeros our parameterization can hold
   const unsigned int maxPiZeros = PFTau::kOneProngNPiZero;
   // Determine our track index
   unsigned int nCharged = pfChs.size();
   if(nCharged>0){
     unsigned int trackIndex = (nCharged - 1)*(maxPiZeros + 1);
     // Check if we handle the given number of tracks
     if(trackIndex >= PFTau::kRareDecayMode) 
       dm = PFTau::kRareDecayMode;    
     else
       dm = static_cast<PFTau::hadronicDecayMode>(trackIndex + std::min(nPiZeros,maxPiZeros) );
   }
   else{
     dm = PFTau::kNull;
   }
   aTau.setDecayMode(dm);
   return;
 }

Member Data Documentation

JetFunc reco::tau::RecoTauBuilderConePlugin::isoConeChargedHadrons_

private

Definition at line 56 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::isoConeNeutralHadrons_

private

Definition at line 61 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::isoConePiZeros_

private

Definition at line 59 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

double reco::tau::RecoTauBuilderConePlugin::leadObjecPtThreshold_

private

Definition at line 48 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::matchingCone_

private

Definition at line 54 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

int reco::tau::RecoTauBuilderConePlugin::maxSignalConeChargedHadrons_

private

Definition at line 63 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

double reco::tau::RecoTauBuilderConePlugin::minAbsPhotonSumPt_insideSignalCone_

private

Definition at line 64 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

double reco::tau::RecoTauBuilderConePlugin::minRelPhotonSumPt_insideSignalCone_

private

Definition at line 65 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

RecoTauQualityCuts reco::tau::RecoTauBuilderConePlugin::qcuts_

private

Definition at line 44 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::signalConeChargedHadrons_

private

Definition at line 55 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::signalConeNeutralHadrons_

private

Definition at line 60 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

JetFunc reco::tau::RecoTauBuilderConePlugin::signalConePiZeros_

private

Definition at line 57 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

StringObjectFunction<reco::PFTau> reco::tau::RecoTauBuilderConePlugin::signalConeSizeToStore_

private

Definition at line 58 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

bool reco::tau::RecoTauBuilderConePlugin::usePFLeptonsAsChargedHadrons_

private

Definition at line 46 of file RecoTauBuilderConePlugin.cc.

Referenced by operator()().

Private Attributes
JetFunc	isoConeChargedHadrons_

JetFunc	isoConeNeutralHadrons_

JetFunc	isoConePiZeros_

double	leadObjecPtThreshold_

JetFunc	matchingCone_

int	maxSignalConeChargedHadrons_

double	minAbsPhotonSumPt_insideSignalCone_

double	minRelPhotonSumPt_insideSignalCone_

RecoTauQualityCuts	qcuts_

JetFunc	signalConeChargedHadrons_

JetFunc	signalConeNeutralHadrons_

JetFunc	signalConePiZeros_

StringObjectFunction< reco::PFTau >	signalConeSizeToStore_

bool	usePFLeptonsAsChargedHadrons_

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation