Namespaces
	cone

	disc

	helpers

	qcuts

	xclean

Classes
class	AssociationMatchRefSelector

class	Combinatoric

class	CombinatoricGenerator

class	CombinatoricIterator

class	PFRecoTauChargedHadronBuilderPlugin

class	PFRecoTauChargedHadronFromPFCandidatePlugin

class	PFRecoTauChargedHadronFromTrackPlugin

class	PFRecoTauChargedHadronQualityPlugin

class	PFRecoTauChargedHadronStringQuality

class	PFRecoTauEnergyAlgorithmPlugin

class	RecoTauBuilderCombinatoricPlugin

class	RecoTauBuilderConePlugin

class	RecoTauBuilderPlugin

class	RecoTauCleanerPlugin

class	RecoTauConstructor

class	RecoTauDiscriminantCleanerPlugin

class	RecoTauDiscriminantFromDiscriminator

class	RecoTauDiscriminantFunctionPlugin

class	RecoTauDiscriminantInvariantWidth

class	RecoTauDiscriminantPlugin

class	RecoTauDiscriminantVectorFunctionPlugin

class	RecoTauDiscriminationBinnedIsolation

class	RecoTauDiscriminationBinnedIsolationImpl

class	RecoTauElectronRejectionPlugin

class	RecoTauEnergyRecoveryPlugin2

class	RecoTauEventHolderPlugin

class	RecoTauImpactParameterSignificancePlugin

class	RecoTauIsolationMasking

class	RecoTauLexicographicalRanking

class	RecoTauModifierPlugin

class	RecoTauNamedPlugin

class	RecoTauObjectEmbedder

class	RecoTauPhotonFilter

class	RecoTauPiZeroBuilderPlugin

class	RecoTauPiZeroCombinatoricPlugin

class	RecoTauPiZeroQualityPlugin

class	RecoTauPiZeroStringQuality

class	RecoTauPiZeroStripPlugin

class	RecoTauPiZeroStripPlugin2

class	RecoTauPiZeroTrivialPlugin

class	RecoTauQualityCuts

class	RecoTauRandomCleanerPlugin

class	RecoTauStringCleanerPlugin

class	RecoTauTagInfoWorkaroundModifer

class	RecoTauTwoProngFilter

class	RecoTauVertexAssociator

class	SortByDescendingPt

class	SortPFCandsDescendingPt

Typedefs
typedef tau::CombinatoricGenerator < ChargedHadronList >	ChargedHadronCombo

typedef std::vector < reco::PFRecoTauChargedHadron >	ChargedHadronList

typedef tau::CombinatoricGenerator < PiZeroList >	PiZeroCombo

typedef std::vector < RecoTauPiZero >	PiZeroList

Functions
template<typename RefVectorType , typename BaseView >
RefVectorType	castView (const edm::Handle< BaseView > &view)
	Convert a BaseView (View<T>) to a TRefVector. More...

unsigned int	chargedHadronsInDecayMode (PFTau::hadronicDecayMode mode)
	Reverse mapping of decay modes into multiplicities. More...

template<typename Container , class OverlapFunction >
Container	cleanOverlaps (const Container &dirty)

reco::Candidate::LorentzVector	compChargedHadronP4fromPThetaPhi (double, double, double)

reco::Candidate::LorentzVector	compChargedHadronP4fromPxPyPz (double, double, double)

std::string	discPluginName (const std::string &mvaName)

std::pair< edm::ParameterSet, edm::ParameterSet >	factorizePUQCuts (const edm::ParameterSet &inputSet)

template<typename Iterator >
std::vector< PFCandidatePtr >	filterPFCandidates (const Iterator &begin, const Iterator &end, int particleId, bool sort=true)

std::vector< PFCandidatePtr >	flattenPiZeros (const std::vector< RecoTauPiZero >::const_iterator &, const std::vector< RecoTauPiZero >::const_iterator &)
	Flatten a list of pi zeros into a list of there constituent PFCandidates. More...

std::vector< PFCandidatePtr >	flattenPiZeros (const std::vector< RecoTauPiZero > &)

PFTau::hadronicDecayMode	getDecayMode (const reco::GenJet *genJet)

template<typename InputIterator >
InputIterator	leadPFCand (InputIterator begin, InputIterator end)

void	markCandsInStrip (std::vector< bool > &candFlags, const std::set< size_t > &candIds)

std::vector< PFCandidatePtr >	pfCandidates (const PFJet &jet, int particleId, bool sort=true)

std::vector< PFCandidatePtr >	pfCandidates (const PFJet &jet, const std::vector< int > &particleIds, bool sort=true)
	Extract pfCandidates of a that match a list of particle Ids from a PFJet. More...

std::vector< PFCandidatePtr >	pfChargedCands (const PFJet &jet, bool sort=true)
	Extract all non-neutral candidates from a PFJet. More...

std::vector< PFCandidatePtr >	pfGammas (const PFJet &jet, bool sort=true)
	Extract all pfGammas from a PFJet. More...

unsigned int	piZerosInDecayMode (PFTau::hadronicDecayMode mode)

void	setChargedHadronP4 (reco::PFRecoTauChargedHadron &chargedHadron, double scaleFactor_neutralPFCands=1.0)

template<typename InputIterator >
int	sumPFCandCharge (InputIterator begin, InputIterator end)
	Sum the charge of a collection of PFCandidates. More...

template<typename InputIterator >
reco::Candidate::LorentzVector	sumPFCandP4 (InputIterator begin, InputIterator end)

template<typename InputIterator >
double	sumPFCandPt (InputIterator begin, InputIterator end)
	Sum the pT of a collection of PFCandidates. More...

template<typename InputIterator , typename FunctionPtr , typename ReturnType >
ReturnType	sumPFVector (InputIterator begin, InputIterator end, FunctionPtr func, ReturnType init)
	Sum the four vectors in a collection of PFCandidates. More...

template<typename InputIterator >
InputIterator	takeNElements (const InputIterator &begin, const InputIterator &end, size_t N)

PFTau::hadronicDecayMode	translateDecayMode (unsigned int nCharged, unsigned int nPiZero)

PFTau::hadronicDecayMode	translateGenDecayModeToReco (const std::string &genName)
	Convert a genTau decay mode string ('oneProng0Pi0') to the RECO enum. More...

std::string	translateRecoDecayModeToGen (PFTau::hadronicDecayMode decayMode)
	Convert a RECO enum decay mode to a string ('oneProng0Pi0') More...

Variables
bool	vxTrkFiltering

Typedef Documentation

typedef tau::CombinatoricGenerator<ChargedHadronList> reco::tau::ChargedHadronCombo

Definition at line 20 of file RecoTauBuilderCombinatoricPlugin.cc.

typedef std::vector<reco::PFRecoTauChargedHadron> reco::tau::ChargedHadronList

Definition at line 19 of file RecoTauBuilderCombinatoricPlugin.cc.

typedef tau::CombinatoricGenerator<PiZeroList> reco::tau::PiZeroCombo

Definition at line 22 of file RecoTauBuilderCombinatoricPlugin.cc.

typedef std::vector< RecoTauPiZero > reco::tau::PiZeroList

Definition at line 21 of file RecoTauBuilderCombinatoricPlugin.cc.

Function Documentation

template<typename RefVectorType , typename BaseView >

RefVectorType reco::tau::castView ( const edm::Handle< BaseView > & view )

Convert a BaseView (View<T>) to a TRefVector.

Definition at line 74 of file RecoTauCommonUtilities.h.

References i, convertSQLitetoXML_cfg::output, and relativeConstraints::value.

                                                         {
   typedef typename RefVectorType::value_type OutputRef;
   // Double check at compile time that the inheritance is okay.  It can still
   // fail at runtime if you pass it the wrong collection.
   BOOST_STATIC_ASSERT(
       (boost::is_base_of<typename BaseView::value_type,
                          typename RefVectorType::member_type>::value));
   RefVectorType output;
   size_t nElements = view->size();
   output.reserve(nElements);
   // Cast each of our Refs
   for (size_t i = 0; i < nElements; ++i) {
     output.push_back(view->refAt(i).template castTo<OutputRef>());
   }
   return output;
 }

unsigned int reco::tau::chargedHadronsInDecayMode ( PFTau::hadronicDecayMode mode )

Reverse mapping of decay modes into multiplicities.

Definition at line 45 of file PFTauDecayModeTools.cc.

References reco::PFTau::kOneProngNPiZero, and alignBH_cfg::mode.

                                                                     {
    int modeAsInt = static_cast<int>(mode);
    return (modeAsInt / PFTau::kOneProngNPiZero) + 1;
 }

template<typename Container , class OverlapFunction >

Container reco::tau::cleanOverlaps ( const Container & dirty )

Definition at line 35 of file RecoTauCleaningTools.h.

References clean, and analyzePatCleaning_cfg::overlaps.

                                                 {
   typedef typename Container::const_iterator Iterator;
   // Output container of clean objects
   Container clean;
   OverlapFunction overlapChecker;
   for (Iterator candidate = dirty.begin(); candidate != dirty.end();
        ++candidate) {
     // Check if this overlaps with a pizero already in the clean list
     bool overlaps = false;
     for (Iterator cleaned = clean.begin();
          cleaned != clean.end() && !overlaps; ++cleaned) {
       overlaps = overlapChecker(*candidate, *cleaned);
     }
     // If it didn't overlap with anything clean, add it to the clean list
     if (!overlaps)
       clean.insert(clean.end(), *candidate);
   }
   return clean;
 }

reco::Candidate::LorentzVector reco::tau::compChargedHadronP4fromPThetaPhi	(	double	chargedHadronP,
		double	chargedHadronTheta,
		double	chargedHadronPhi
	)

Definition at line 58 of file pfRecoTauChargedHadronAuxFunctions.cc.

References compChargedHadronP4fromPxPyPz().

 {
   double chargedHadronPx = chargedHadronP*TMath::Cos(chargedHadronPhi)*TMath::Sin(chargedHadronTheta);
   double chargedHadronPy = chargedHadronP*TMath::Sin(chargedHadronPhi)*TMath::Sin(chargedHadronTheta);
   double chargedHadronPz = chargedHadronP*TMath::Cos(chargedHadronTheta);    
   return compChargedHadronP4fromPxPyPz(chargedHadronPx, chargedHadronPy, chargedHadronPz);
 }

reco::Candidate::LorentzVector reco::tau::compChargedHadronP4fromPxPyPz	(	double	chargedHadronPx,
		double	chargedHadronPy,
		double	chargedHadronPz
	)

Definition at line 50 of file pfRecoTauChargedHadronAuxFunctions.cc.

References mathSSE::sqrt().

Referenced by compChargedHadronP4fromPThetaPhi(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), and setChargedHadronP4().

 {
   const double chargedPionMass = 0.13957; // GeV  
   double chargedHadronEn = sqrt(chargedHadronPx*chargedHadronPx + chargedHadronPy*chargedHadronPy + chargedHadronPz*chargedHadronPz + chargedPionMass*chargedPionMass);  
   reco::Candidate::LorentzVector chargedHadronP4(chargedHadronPx, chargedHadronPy, chargedHadronPz, chargedHadronEn);
   return chargedHadronP4;
 }

std::string reco::tau::discPluginName ( const std::string & mvaName )

inline

Definition at line 23 of file RecoTauDiscriminantPlugins.h.

References PFRecoTauDiscriminationAgainstMuonMVA_cfi::mvaName.

Referenced by PFTauMVAInputDiscriminantTranslator::PFTauMVAInputDiscriminantTranslator().

                                                           {
   return "RecoTauDiscrimination" + mvaName;
 }

std::pair< edm::ParameterSet, edm::ParameterSet > reco::tau::factorizePUQCuts ( const edm::ParameterSet & inputSet )

Definition at line 352 of file RecoTauQualityCuts.cc.

References edm::ParameterSet::copyFrom(), GOODCOLL_filter_cfg::cut, edm::ParameterSet::getParameterNames(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PFRecoTauDiscriminationByIsolation::PFRecoTauDiscriminationByIsolation().

 {
   edm::ParameterSet puCuts;
   edm::ParameterSet nonPUCuts;
 
   std::vector<std::string> inputNames = input.getParameterNames();
   BOOST_FOREACH( const std::string& cut, inputNames ) {
     if ( cut == "minTrackVertexWeight" || 
      cut == "maxDeltaZ"            ||
      cut == "maxDeltaZToLeadTrack" ) {
       puCuts.copyFrom(input, cut);
     } else {
       nonPUCuts.copyFrom(input, cut);
     }
   }
   return std::make_pair(puCuts, nonPUCuts);
 }

template<typename Iterator >

std::vector<PFCandidatePtr> reco::tau::filterPFCandidates	(	const Iterator &	begin,
		const Iterator &	end,
		int	particleId,
		bool	sort = `true`
	)

Filter a collection of objects that are convertible to PFCandidatePtrs by PFCandidate ID

Definition at line 40 of file RecoTauCommonUtilities.h.

References end, convertSQLitetoXML_cfg::output, and python.multivaluedict::sort().

Referenced by pfCandidates().

                                     {
   std::vector<PFCandidatePtr> output;
   for(Iterator iter = begin; iter != end; ++iter) {
     reco::PFCandidatePtr ptr(*iter);
     if (ptr->particleId() == particleId)
       output.push_back(ptr);
   }
   if (sort) std::sort(output.begin(), output.end(), SortPFCandsDescendingPt());
   return output;
 }

std::vector< PFCandidatePtr > reco::tau::flattenPiZeros	(	const std::vector< RecoTauPiZero >::const_iterator &	piZerosBegin,
		const std::vector< RecoTauPiZero >::const_iterator &	piZerosEnd
	)

Flatten a list of pi zeros into a list of there constituent PFCandidates.

Definition at line 16 of file RecoTauCommonUtilities.cc.

References convertSQLitetoXML_cfg::output.

Referenced by flattenPiZeros(), reco::tau::xclean::CrossCleanPtrs< PtrIter >::initialize(), and reco::tau::RecoTauPhotonFilter::operator()().

                                                                                                                                      {
   std::vector<PFCandidatePtr> output;
 
   for(std::vector<RecoTauPiZero>::const_iterator piZero = piZerosBegin;
       piZero != piZerosEnd; ++piZero) {
     for(size_t iDaughter = 0; iDaughter < piZero->numberOfDaughters();
         ++iDaughter) {
       output.push_back(PFCandidatePtr(piZero->daughterPtr(iDaughter)));
     }
   }
   return output;
 }

std::vector< PFCandidatePtr > reco::tau::flattenPiZeros ( const std::vector< RecoTauPiZero > & piZeros )

Definition at line 30 of file RecoTauCommonUtilities.cc.

References flattenPiZeros().

                                                         {
   return flattenPiZeros(piZeros.begin(), piZeros.end()); 
 }

PFTau::hadronicDecayMode reco::tau::getDecayMode ( const reco::GenJet * genJet )

Definition at line 80 of file PFTauDecayModeTools.cc.

References JetMCTagUtils::genTauDecayMode(), reco::PFTau::kNull, and translateGenDecayModeToReco().

Referenced by tautools::RecoTauDecayModeTruthMatchPlugin::operator()().

                                                               {
   if (!genJet)
     return reco::PFTau::kNull;
   return translateGenDecayModeToReco(JetMCTagUtils::genTauDecayMode(*genJet));
 }

template<typename InputIterator >

InputIterator reco::tau::leadPFCand	(	InputIterator	begin,
		InputIterator	end
	)

Definition at line 132 of file RecoTauCommonUtilities.h.

References begin, and end.

Referenced by reco::tau::RecoTauConstructor::get(), and reco::tau::RecoTauBuilderConePlugin::operator()().

                        {
     double max_pt = 0;
     InputIterator max_cand = begin;
     for(InputIterator cand = begin; cand != end; ++cand) {
       if( (*cand)->pt() > max_pt ) {
         max_pt = (*cand)->pt();
         max_cand = cand;
       }
     }
     return max_cand;
   }

void reco::tau::markCandsInStrip	(	std::vector< bool > &	candFlags,
		const std::set< size_t > &	candIds
	)

Definition at line 165 of file RecoTauPiZeroStripPlugin2.cc.

Referenced by reco::tau::RecoTauPiZeroStripPlugin2::operator()().

 {
   for ( std::set<size_t>::const_iterator candId = candIds.begin();
     candId != candIds.end(); ++candId ) {
     candFlags[*candId] = true;
   }
 }

std::vector< reco::PFCandidatePtr > reco::tau::pfCandidates	(	const PFJet &	jet,
		int	particleId,
		bool	sort = `true`
	)

Extract pfCandidates of a given particle Id from a PFJet. If sort is true, candidates will be sorted by descending PT

Definition at line 34 of file RecoTauCommonUtilities.cc.

References filterPFCandidates(), reco::PFJet::getPFConstituents(), and python.multivaluedict::sort().

Referenced by PFMETAnalyzer::analyze(), MCEmbeddingValidationAnalyzer::analyze(), PFRecoTauDiscriminationByIsolation::beginEvent(), GEDGsfElectronProducer::fillGsfElectronValueMap(), PFElectronTranslator::fillMVAValueMap(), GreedyMuonPFCandidateFilter::filter(), InconsistentMuonPFCandidateFilter::filter(), FixedGridEnergyDensity::fixedGridRho(), GEDGsfElectronProducer::matchWithPFCandidates(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), reco::tau::RecoTauBuilderConePlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), pfCandidates(), pfChargedCands(), pfGammas(), FSPFProducer::produce(), PFMuonCaloCleaner::produce(), reco::ParticleFlowForChargedMETProducer::produce(), PFElectronTranslator::produce(), HLTHtMhtProducer::produce(), PFLinker::produce(), PFMET::produce(), MuonPFCandidateCleaner::produce(), PFPileUp::produce(), BoostedTauSeedsProducer::produce(), pat::PATPFParticleProducer::produce(), reco::modules::HICaloCompatibleTrackSelector::produce(), FFTJetPFPileupCleaner::produce(), MuonProducer::produce(), PFPhotonTranslator::produce(), and PFMETAnalyzer::validateMET().

                                {
   PFCandPtrs pfCands = jet.getPFConstituents();
   PFCandPtrs selectedPFCands = filterPFCandidates(
       pfCands.begin(), pfCands.end(), particleId, sort);
   return selectedPFCands;
 }

std::vector< reco::PFCandidatePtr > reco::tau::pfCandidates	(	const PFJet &	jet,
		const std::vector< int > &	particleIds,
		bool	sort = `true`
	)

Extract pfCandidates of a that match a list of particle Ids from a PFJet.

Definition at line 42 of file RecoTauCommonUtilities.cc.

References convertSQLitetoXML_cfg::output, pfCandidates(), and python.multivaluedict::sort().

                                                   {
   PFCandPtrs output;
   // Get each desired candidate type, unsorted for now
   for(std::vector<int>::const_iterator particleId = particleIds.begin();
       particleId != particleIds.end(); ++particleId) {
     PFCandPtrs selectedPFCands = pfCandidates(jet, *particleId, false);
     output.insert(output.end(), selectedPFCands.begin(), selectedPFCands.end());
   }
   if (sort) std::sort(output.begin(), output.end(), SortPFCandsDescendingPt());
   return output;
 }

std::vector< reco::PFCandidatePtr > reco::tau::pfChargedCands	(	const PFJet &	jet,
		bool	sort = `true`
	)

Extract all non-neutral candidates from a PFJet.

Definition at line 59 of file RecoTauCommonUtilities.cc.

References reco::PFCandidate::e, reco::PFCandidate::h, reco::PFCandidate::mu, convertSQLitetoXML_cfg::output, pfCandidates(), and python.multivaluedict::sort().

Referenced by reco::tau::RecoTauVertexAssociator::getLeadTrack(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

                                                             {
   PFCandPtrs output;
   PFCandPtrs mus = pfCandidates(jet, reco::PFCandidate::mu, false);
   PFCandPtrs es = pfCandidates(jet, reco::PFCandidate::e, false);
   PFCandPtrs chs = pfCandidates(jet, reco::PFCandidate::h, false);
   output.reserve(mus.size() + es.size() + chs.size());
   output.insert(output.end(), mus.begin(), mus.end());
   output.insert(output.end(), es.begin(), es.end());
   output.insert(output.end(), chs.begin(), chs.end());
   if (sort) std::sort(output.begin(), output.end(), SortPFCandsDescendingPt());
   return output;
 }

std::vector< reco::PFCandidatePtr > reco::tau::pfGammas	(	const PFJet &	jet,
		bool	sort = `true`
	)

Extract all pfGammas from a PFJet.

Definition at line 55 of file RecoTauCommonUtilities.cc.

References reco::PFCandidate::gamma, and pfCandidates().

Referenced by reco::tau::RecoTauPiZeroTrivialPlugin::operator()(), reco::tau::RecoTauPiZeroCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

                                                                         {
   return pfCandidates(jet, reco::PFCandidate::gamma, sort);
 }

unsigned int reco::tau::piZerosInDecayMode ( PFTau::hadronicDecayMode mode )

Definition at line 50 of file PFTauDecayModeTools.cc.

References reco::PFTau::kOneProngNPiZero, and alignBH_cfg::mode.

                                                              {
    int modeAsInt = static_cast<int>(mode);
    return (modeAsInt % PFTau::kOneProngNPiZero);
 }

void reco::tau::setChargedHadronP4	(	reco::PFRecoTauChargedHadron &	chargedHadron,
		double	scaleFactor_neutralPFCands = `1.0`
	)

Definition at line 10 of file pfRecoTauChargedHadronAuxFunctions.cc.

References reco::PFRecoTauChargedHadron::algoIs(), compChargedHadronP4fromPxPyPz(), reco::PFRecoTauChargedHadron::getChargedPFCandidate(), reco::PFRecoTauChargedHadron::getNeutralPFCandidates(), reco::PFRecoTauChargedHadron::getTrack(), edm::Ptr< T >::isNonnull(), reco::PFRecoTauChargedHadron::kChargedPFCandidate, reco::PFRecoTauChargedHadron::kPFNeutralHadron, reco::PFRecoTauChargedHadron::kTrack, and reco::LeafCandidate::setP4().

Referenced by reco::tau::RecoTauConstructor::addTauChargedHadron(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromTrackPlugin::operator()(), and PFRecoTauChargedHadronProducer::produce().

 {
   double chargedHadronP  = 0.;
   double chargedHadronPx = 0.;
   double chargedHadronPy = 0.;
   double chargedHadronPz = 0.;
   double SumNeutrals = 0.;
   if ( chargedHadron.algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate) ||
        chargedHadron.algoIs(reco::PFRecoTauChargedHadron::kPFNeutralHadron)   ) {
     const reco::PFCandidatePtr& chargedPFCand = chargedHadron.getChargedPFCandidate();
     assert(chargedPFCand.isNonnull());
     chargedHadronP     += chargedPFCand->p();
     chargedHadronPx     = chargedPFCand->px();
     chargedHadronPy     = chargedPFCand->py();
     chargedHadronPz     = chargedPFCand->pz();
   } else if ( chargedHadron.algoIs(reco::PFRecoTauChargedHadron::kTrack) ) {
     const reco::PFRecoTauChargedHadron::TrackPtr& track = chargedHadron.getTrack();
     assert(track.isNonnull());
     chargedHadronP     += track->p();
     chargedHadronPx     = track->px();
     chargedHadronPy     = track->py();
     chargedHadronPz     = track->pz();
   } else assert(0);
   const std::vector<reco::PFCandidatePtr>& neutralPFCands = chargedHadron.getNeutralPFCandidates();
   for ( std::vector<reco::PFCandidatePtr>::const_iterator neutralPFCand = neutralPFCands.begin();
     neutralPFCand != neutralPFCands.end(); ++neutralPFCand ) {
     SumNeutrals += (*neutralPFCand)->p();
   }
   double noNeutrals=chargedHadronP;
   chargedHadronP+=scaleFactor_neutralPFCands*SumNeutrals;
   double ptRatio=chargedHadronP/noNeutrals;
   chargedHadronPx*=ptRatio;
   chargedHadronPy*=ptRatio;
   chargedHadronPz*=ptRatio;
   
       
   reco::Candidate::LorentzVector chargedHadronP4 = compChargedHadronP4fromPxPyPz(chargedHadronPx, chargedHadronPy, chargedHadronPz);
   chargedHadron.setP4(chargedHadronP4);
 }

template<typename InputIterator >

int reco::tau::sumPFCandCharge	(	InputIterator	begin,
		InputIterator	end
	)

Sum the charge of a collection of PFCandidates.

Definition at line 127 of file RecoTauCommonUtilities.h.

References reco::LeafCandidate::charge(), and sumPFVector().

                        {
     return sumPFVector(begin, end, &PFCandidate::charge, 0);
   }

template<typename InputIterator >

reco::Candidate::LorentzVector reco::tau::sumPFCandP4	(	InputIterator	begin,
		InputIterator	end
	)

Definition at line 114 of file RecoTauCommonUtilities.h.

References reco::LeafCandidate::p4(), and sumPFVector().

                                             {
   return sumPFVector(begin, end, &PFCandidate::p4,
       reco::Candidate::LorentzVector());
 }

template<typename InputIterator >

double reco::tau::sumPFCandPt	(	InputIterator	begin,
		InputIterator	end
	)

Sum the pT of a collection of PFCandidates.

Definition at line 121 of file RecoTauCommonUtilities.h.

References reco::LeafCandidate::pt(), and sumPFVector().

Referenced by reco::tau::RecoTauConstructor::get().

                        {
     return sumPFVector(begin, end, &PFCandidate::pt, 0.0);
   }

template<typename InputIterator , typename FunctionPtr , typename ReturnType >

ReturnType reco::tau::sumPFVector	(	InputIterator	begin,
		InputIterator	end,
		FunctionPtr	func,
		ReturnType	init
	)

Sum the four vectors in a collection of PFCandidates.

Definition at line 104 of file RecoTauCommonUtilities.h.

References end, statics::func, init, and convertSQLitetoXML_cfg::output.

Referenced by sumPFCandCharge(), sumPFCandP4(), and sumPFCandPt().

                                          {
     ReturnType output = init;
     for(InputIterator cand = begin; cand != end; ++cand) {
       //#define CALL_MEMBER_FN(object,ptrToMember)  ((object).*(ptrToMember))
       output += ((**cand).*(func))();
     }
     return output;
   }

template<typename InputIterator >

InputIterator reco::tau::takeNElements	(	const InputIterator &	begin,
		const InputIterator &	end,
		size_t	N
	)

Definition at line 96 of file RecoTauCommonUtilities.h.

References begin, and N.

Referenced by reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), reco::tau::RecoTauPiZeroCombinatoricPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), and reco::tau::RecoTauPiZeroStripPlugin2::operator()().

                                                                     {
   size_t input_size = end - begin;
   return (N > input_size) ? end : begin + N;
 }

PFTau::hadronicDecayMode reco::tau::translateDecayMode	(	unsigned int	nCharged,
		unsigned int	nPiZero
	)

Definition at line 55 of file PFTauDecayModeTools.cc.

References reco::PFTau::kNull, reco::PFTau::kOneProngNPiZero, and reco::PFTau::kRareDecayMode.

Referenced by reco::tau::RecoTauObjectEmbedder< T >::operator()(), reco::tau::RecoTauDiscriminantInvariantWidth::RecoTauDiscriminantInvariantWidth(), and RecoTauMVATransform::RecoTauMVATransform().

                                                   {
    // If no tracks exist, this is definitely not a tau!
    if(!nCharged) return PFTau::kNull;
    // Find the maximum number of PiZeros our parameterization can hold
    const unsigned int maxPiZeros = PFTau::kOneProngNPiZero;
    // Determine our track index
    unsigned int trackIndex = (nCharged-1)*(maxPiZeros+1);
    // Check if we handle the given number of tracks
    if(trackIndex >= PFTau::kRareDecayMode) return PFTau::kRareDecayMode;
 
    nPiZeros = (nPiZeros <= maxPiZeros) ? nPiZeros : maxPiZeros;
    return static_cast<PFTau::hadronicDecayMode>(trackIndex + nPiZeros);
 }

PFTau::hadronicDecayMode reco::tau::translateGenDecayModeToReco ( const std::string & genName )

Convert a genTau decay mode string ('oneProng0Pi0') to the RECO enum.

Definition at line 70 of file PFTauDecayModeTools.cc.

Referenced by getDecayMode().

                            {
   return decayModeStringToId(name.c_str(), dmTranslatorMap);
 }

std::string reco::tau::translateRecoDecayModeToGen ( PFTau::hadronicDecayMode decayMode )

Convert a RECO enum decay mode to a string ('oneProng0Pi0')

Definition at line 75 of file PFTauDecayModeTools.cc.

                                                                         {
   return decayModeIdToString(decayMode, dmTranslatorMap);
 }

Variable Documentation

bool reco::tau::vxTrkFiltering

Definition at line 17 of file RecoTauVertexAssociator.cc.

Referenced by reco::tau::RecoTauVertexAssociator::getLeadTrack(), and reco::tau::RecoTauVertexAssociator::RecoTauVertexAssociator().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation