reco::tau Namespace Reference

Namespaces
	cone
	qcuts
	xclean

Classes
class	Combinatoric
class	CombinatoricGenerator
class	CombinatoricIterator
class	PATTauDiscriminationByMVAIsolationRun2
class	PFRecoTauChargedHadronBuilderPlugin
class	PFRecoTauChargedHadronFromGenericTrackPlugin
class	PFRecoTauChargedHadronFromPFCandidatePlugin
class	PFRecoTauChargedHadronQualityPlugin
class	PFRecoTauChargedHadronStringQuality
class	PFRecoTauDiscriminationByMVAIsolationRun2
class	PFRecoTauEnergyAlgorithmPlugin
class	PFRecoTauLostTrackPlugin
class	PFRecoTauMassPlugin
class	RecoTauBuilderCombinatoricPlugin
class	RecoTauBuilderConePlugin
class	RecoTauBuilderPlugin
class	RecoTauChargeCleanerPlugin
class	RecoTauChargedHadronMultiplicityCleanerPlugin
class	RecoTauCleanerPlugin
class	RecoTauConstructor
class	RecoTauDiscriminantCleanerPlugin
class	RecoTauElectronRejectionPlugin
class	RecoTauEnergyRecoveryPlugin2
class	RecoTauEventHolderPlugin
class	RecoTauImpactParameterSignificancePlugin
class	RecoTauLexicographicalRanking
class	RecoTauModifierPlugin
class	RecoTauNamedPlugin
class	RecoTauPiZeroBuilderPlugin
class	RecoTauPiZeroCombinatoricPlugin
class	RecoTauPiZeroQualityPlugin
class	RecoTauPiZeroStringQuality
class	RecoTauPiZeroStripPlugin
class	RecoTauPiZeroStripPlugin2
class	RecoTauPiZeroStripPlugin3
class	RecoTauPiZeroTrivialPlugin
class	RecoTauQualityCuts
class	RecoTauSoftTwoProngTausCleanerPlugin
class	RecoTauStringCleanerPlugin
class	RecoTauTagInfoWorkaroundModifer
class	RecoTauTwoProngFilter
class	RecoTauVertexAssociator
class	SortPFCandsDescendingPt

Typedefs
typedef tau::CombinatoricGenerator< ChargedHadronList >	ChargedHadronCombo
typedef std::vector< reco::PFRecoTauChargedHadron >	ChargedHadronList
typedef PFRecoTauChargedHadronFromGenericTrackPlugin< pat::PackedCandidate >	PFRecoTauChargedHadronFromLostTrackPlugin
typedef PFRecoTauChargedHadronFromGenericTrackPlugin< reco::Track >	PFRecoTauChargedHadronFromTrackPlugin
typedef tau::CombinatoricGenerator< PiZeroList >	PiZeroCombo
typedef std::vector< RecoTauPiZero >	PiZeroList

Enumerations
enum	{   kOldDMwoLT, kOldDMwLT, kNewDMwoLT, kNewDMwLT,   kDBoldDMwLT, kDBnewDMwLT, kPWoldDMwLT, kPWnewDMwLT,   kDBoldDMwLTwGJ, kDBnewDMwLTwGJ, kDBnewDMwLTwGJPhase2 }

Functions
math::XYZPointF	atECALEntrance (const reco::Candidate *part, double bField)
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)
void	countHits (const reco::Muon &muon, std::vector< int > &numHitsDT, std::vector< int > &numHitsCSC, std::vector< int > &numHitsRPC)
void	countMatches (const reco::Muon &muon, std::vector< int > &numMatchesDT, std::vector< int > &numMatchesCSC, std::vector< int > &numMatchesRPC)
float	eratio (const reco::PFTau &tau)
	return ratio of energy in ECAL over sum of energy in ECAL and HCAL More...
float	eratio (const pat::Tau &tau)
std::pair< edm::ParameterSet, edm::ParameterSet >	factorizePUQCuts (const edm::ParameterSet &inputSet)
bool	fillIsoMVARun2Inputs (float *mvaInput, const pat::Tau &tau, int mvaOpt, const std::string &nameCharged, const std::string &nameNeutral, const std::string &namePu, const std::string &nameOutside, const std::string &nameFootprint)
template<typename Iterator >
std::vector< CandidatePtr >	filterPFCandidates (const Iterator &begin, const Iterator &end, int pdgId, bool sort=true)
std::vector< CandidatePtr >	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< CandidatePtr >	flattenPiZeros (const std::vector< RecoTauPiZero > &)
std::string	format_vint (const std::vector< int > &vi)
PFTau::hadronicDecayMode	getDecayMode (const reco::GenJet *genJet)
const reco::Track *	getTrackFromChargedHadron (const reco::PFRecoTauChargedHadron &chargedHadron)
template<class Base , class Der >
bool	isPtrEqual (const edm::Ptr< Base > &b, const edm::Ptr< Der > &d)
template<class Base >
bool	isPtrEqual (const edm::Ptr< Base > &b, const edm::Ptr< Base > &d)
float	lead_track_chi2 (const reco::PFTau &tau)
	return chi2 of the leading track ==> deprecated? <== More...
template<typename InputIterator >
InputIterator	leadCand (InputIterator begin, InputIterator end)
unsigned int	n_photons_total (const reco::PFTau &tau)
	return total number of pf photon candidates with pT>500 MeV, which are associated to signal More...
unsigned int	n_photons_total (const pat::Tau &tau)
std::vector< CandidatePtr >	pfCandidates (const Jet &jet, int particleId, bool sort=true)
std::vector< CandidatePtr >	pfCandidates (const Jet &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< CandidatePtr >	pfCandidatesByPdgId (const Jet &jet, int pdgId, bool sort=true)
std::vector< CandidatePtr >	pfCandidatesByPdgId (const Jet &jet, const std::vector< int > &pdgIds, bool sort=true)
	Extract pfCandidates of a that match a list of PDG Ids from a PFJet. More...
std::vector< CandidatePtr >	pfChargedCands (const Jet &jet, bool sort=true)
	Extract all non-neutral candidates from a PFJet. More...
std::vector< CandidatePtr >	pfGammas (const Jet &jet, bool sort=true)
	Extract all pfGammas from a PFJet. More...
unsigned int	piZerosInDecayMode (PFTau::hadronicDecayMode mode)
float	pt_weighted_deta_strip (const reco::PFTau &tau, int dm)
float	pt_weighted_deta_strip (const pat::Tau &tau, int dm)
float	pt_weighted_dphi_strip (const reco::PFTau &tau, int dm)
float	pt_weighted_dphi_strip (const pat::Tau &tau, int dm)
float	pt_weighted_dr_iso (const reco::PFTau &tau, int dm)
float	pt_weighted_dr_iso (const pat::Tau &tau, int dm)
float	pt_weighted_dr_signal (const reco::PFTau &tau, int dm)
float	pt_weighted_dr_signal (const pat::Tau &tau, int dm)
float	pt_weighted_dx (const reco::PFTau &tau, int mode=0, int var=0, int decaymode=-1)
float	pt_weighted_dx (const pat::Tau &tau, int mode=0, int var=0, int decaymode=-1)
template<typename T >
float	pt_weighted_dx_T (const typename T::Tau_t &tau, int mode, int var, int decaymode)
static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker< edm::ParameterSetDescriptionFiller< PATTauDiscriminationByMVAIsolationRun2 > >	s_filler_0__LINE__ ("PATTauDiscriminationByMVAIsolationRun2")
static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker< edm::ParameterSetDescriptionFiller< PFRecoTauDiscriminationByMVAIsolationRun2 > >	s_filler_0__LINE__ ("PFRecoTauDiscriminationByMVAIsolationRun2")
static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< PATTauDiscriminationByMVAIsolationRun2 > >	s_maker__LINE__ ("PATTauDiscriminationByMVAIsolationRun2")
static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< PFRecoTauDiscriminationByMVAIsolationRun2 > >	s_maker__LINE__ ("PFRecoTauDiscriminationByMVAIsolationRun2")
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...

Typedef Documentation

ChargedHadronCombo

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

Definition at line 25 of file RecoTauBuilderCombinatoricPlugin.cc.

ChargedHadronList

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

Definition at line 24 of file RecoTauBuilderCombinatoricPlugin.cc.

PFRecoTauChargedHadronFromLostTrackPlugin

typedef PFRecoTauChargedHadronFromGenericTrackPlugin<pat::PackedCandidate> reco::tau::PFRecoTauChargedHadronFromLostTrackPlugin

Definition at line 348 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

PFRecoTauChargedHadronFromTrackPlugin

typedef PFRecoTauChargedHadronFromGenericTrackPlugin<reco::Track> reco::tau::PFRecoTauChargedHadronFromTrackPlugin

Definition at line 347 of file PFRecoTauChargedHadronFromGenericTrackPlugin.cc.

PiZeroCombo

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

Definition at line 27 of file RecoTauBuilderCombinatoricPlugin.cc.

PiZeroList

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

Definition at line 26 of file RecoTauBuilderCombinatoricPlugin.cc.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kOldDMwoLT
kOldDMwLT
kNewDMwoLT
kNewDMwLT
kDBoldDMwLT
kDBnewDMwLT
kPWoldDMwLT
kPWnewDMwLT
kDBoldDMwLTwGJ
kDBnewDMwLTwGJ
kDBnewDMwLTwGJPhase2

Definition at line 58 of file PFRecoTauClusterVariables.h.

         {
      kOldDMwoLT,
      kOldDMwLT,
      kNewDMwoLT,
      kNewDMwLT,
      kDBoldDMwLT,
      kDBnewDMwLT,
      kPWoldDMwLT,
      kPWnewDMwLT,
      kDBoldDMwLTwGJ,
      kDBnewDMwLTwGJ,
      kDBnewDMwLTwGJPhase2
    };

Function Documentation

atECALEntrance()

math::XYZPointF reco::tau::atECALEntrance	(	const reco::Candidate *	part,
		double	bField
	)

Definition at line 109 of file RecoTauCommonUtilities.cc.

References Calorimetry_cff::bField, RawParticle::charge(), BaseParticlePropagator::getSuccess(), BaseParticlePropagator::particle(), reco::PFCandidate::positionAtECALEntrance(), BaseParticlePropagator::propagateToEcalEntrance(), and RawParticle::vertex().

Referenced by reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), and reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::operator()().

                                                                           {
      const reco::PFCandidate* pfCand = dynamic_cast<const reco::PFCandidate*>(part);
      if (pfCand)
        return pfCand->positionAtECALEntrance();

      math::XYZPointF pos;
      BaseParticlePropagator theParticle = BaseParticlePropagator(
          RawParticle(math::XYZTLorentzVector(part->px(), part->py(), part->pz(), part->energy()),
                      math::XYZTLorentzVector(part->vertex().x(), part->vertex().y(), part->vertex().z(), 0.)),
          part->charge(),
          0.,
          0.,
          bField);
      theParticle.propagateToEcalEntrance(false);
      if (theParticle.getSuccess() != 0) {
        pos = math::XYZPointF(theParticle.particle().vertex());
      }
      return pos;
    }

castView()

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 83 of file RecoTauCommonUtilities.h.

References mps_fire::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.
      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;
    }

chargedHadronsInDecayMode()

unsigned int reco::tau::chargedHadronsInDecayMode

(

PFTau::hadronicDecayMode

mode

)

Reverse mapping of decay modes into multiplicities.

Definition at line 44 of file PFTauDecayModeTools.cc.

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

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

cleanOverlaps()

template<typename Container , class OverlapFunction >

Container reco::tau::cleanOverlaps

(

const Container &

dirty

)

Definition at line 31 of file RecoTauCleaningTools.h.

References clean(), and analyzePatCleaning_cfg::overlaps.

                                                  {
    // Output container of clean objects
    Container clean;
    OverlapFunction overlapChecker;
    for (auto const& candidate : dirty) {
      // Check if this overlaps with a pizero already in the clean list
      bool overlaps = false;
      for (auto 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;
  }

compChargedHadronP4fromPThetaPhi()

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

Definition at line 91 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);
    }

compChargedHadronP4fromPxPyPz()

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

Definition at line 80 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;
    }

countHits()

void reco::tau::countHits	(	const reco::Muon &	muon,
		std::vector< int > &	numHitsDT,
		std::vector< int > &	numHitsCSC,
		std::vector< int > &	numHitsRPC
	)

Definition at line 7 of file RecoTauMuonTools.cc.

References TrackingRecHit::bad, reco::HitPattern::getHitPattern(), reco::HitPattern::getHitType(), reco::HitPattern::getMuonStation(), reco::HitPattern::muonCSCHitFilter(), reco::HitPattern::muonDTHitFilter(), reco::HitPattern::muonHitFilter(), reco::HitPattern::muonRPCHitFilter(), reco::HitPattern::numberOfAllHits(), reco::HitPattern::TRACK_HITS, and TrackingRecHit::valid.

                                               {
      if (muon.outerTrack().isNonnull()) {
        const reco::HitPattern& muonHitPattern = muon.outerTrack()->hitPattern();
        for (int iHit = 0; iHit < muonHitPattern.numberOfAllHits(reco::HitPattern::TRACK_HITS); ++iHit) {
          uint32_t hit = muonHitPattern.getHitPattern(reco::HitPattern::TRACK_HITS, iHit);
          if (hit == 0)
            break;
          if (muonHitPattern.muonHitFilter(hit) && (muonHitPattern.getHitType(hit) == TrackingRecHit::valid ||
                                                    muonHitPattern.getHitType(hit) == TrackingRecHit::bad)) {
            int muonStation = muonHitPattern.getMuonStation(hit) - 1;  // CV: map into range 0..3
            if (muonStation >= 0 && muonStation < 4) {
              if (muonHitPattern.muonDTHitFilter(hit))
                ++numHitsDT[muonStation];
              else if (muonHitPattern.muonCSCHitFilter(hit))
                ++numHitsCSC[muonStation];
              else if (muonHitPattern.muonRPCHitFilter(hit))
                ++numHitsRPC[muonStation];
            }
          }
        }
      }
    }

countMatches()

void reco::tau::countMatches	(	const reco::Muon &	muon,
		std::vector< int > &	numMatchesDT,
		std::vector< int > &	numMatchesCSC,
		std::vector< int > &	numMatchesRPC
	)

Definition at line 46 of file RecoTauMuonTools.cc.

References cms::cuda::assert(), MuonSubdetId::CSC, MuonSubdetId::DT, and MuonSubdetId::RPC.

                                                     {
      const std::vector<reco::MuonChamberMatch>& muonSegments = muon.matches();
      for (std::vector<reco::MuonChamberMatch>::const_iterator muonSegment = muonSegments.begin();
           muonSegment != muonSegments.end();
           ++muonSegment) {
        if (muonSegment->segmentMatches.empty())
          continue;
        int muonDetector = muonSegment->detector();
        int muonStation = muonSegment->station() - 1;
        assert(muonStation >= 0 && muonStation <= 3);
        if (muonDetector == MuonSubdetId::DT)
          ++numMatchesDT[muonStation];
        else if (muonDetector == MuonSubdetId::CSC)
          ++numMatchesCSC[muonStation];
        else if (muonDetector == MuonSubdetId::RPC)
          ++numMatchesRPC[muonStation];
      }
    }

eratio() [1/2]

float reco::tau::eratio

(

const reco::PFTau &

tau

)

return ratio of energy in ECAL over sum of energy in ECAL and HCAL

Definition at line 78 of file PFRecoTauClusterVariables.cc.

References cms::cuda::assert(), pat::PackedCandidate::caloFraction(), reco::PFCandidate::ecalEnergy(), pat::PackedCandidate::energy(), reco::PFCandidate::hcalEnergy(), pat::PackedCandidate::hcalFraction(), and dqmMemoryStats::total.

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

                                       {
      float ecal_en_in_signal_pf_cands = 0;
      float hcal_en_in_signal_pf_cands = 0;
      for (const auto& signal_cand : tau.signalCands()) {
        const reco::PFCandidate* signal_pfcand = dynamic_cast<const reco::PFCandidate*>(signal_cand.get());
        if (signal_pfcand != nullptr) {
          ecal_en_in_signal_pf_cands += signal_pfcand->ecalEnergy();
          hcal_en_in_signal_pf_cands += signal_pfcand->hcalEnergy();
        } else {
          // TauReco@MiniAOD: individual ECAL and HCAL energies recovered from fractions
          const pat::PackedCandidate* signal_pcand = dynamic_cast<const pat::PackedCandidate*>(signal_cand.get());
          assert(signal_pcand);  // Taus are built either from reco::PFCandidates or pat::PackedCandidates
          float calo_en = signal_pcand->caloFraction() * signal_pcand->energy();
          ecal_en_in_signal_pf_cands += calo_en * (1. - signal_pcand->hcalFraction());
          hcal_en_in_signal_pf_cands += calo_en * signal_pcand->hcalFraction();
        }
      }
      float total = ecal_en_in_signal_pf_cands + hcal_en_in_signal_pf_cands;
      if (total == 0.) {
        return -1.;
      }
      return ecal_en_in_signal_pf_cands / total;
    }

eratio() [2/2]

float reco::tau::eratio

(

const pat::Tau &

tau

)

Definition at line 101 of file PFRecoTauClusterVariables.cc.

References dqmMemoryStats::total.

                                    {
      float ecal_en_in_signal_cands = tau.ecalEnergy();
      float hcal_en_in_signal_cands = tau.hcalEnergy();
      float total = ecal_en_in_signal_cands + hcal_en_in_signal_cands;
      if (total == 0.) {
        return -1.;
      }
      return ecal_en_in_signal_cands / total;
    }

factorizePUQCuts()

std::pair< edm::ParameterSet, edm::ParameterSet > reco::tau::factorizePUQCuts

(

const edm::ParameterSet &

inputSet

)

Definition at line 167 of file RecoTauQualityCuts.cc.

References edm::ParameterSet::copyFrom(), DMR_cfg::cut, and input.

Referenced by PFRecoTauDiscriminationByIsolation::PFRecoTauDiscriminationByIsolation(), and PFRecoTauDiscriminationByIsolationContainer::PFRecoTauDiscriminationByIsolationContainer().

                                                                                           {
    edm::ParameterSet puCuts;
    edm::ParameterSet nonPUCuts;

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

fillIsoMVARun2Inputs()

bool reco::tau::fillIsoMVARun2Inputs	(	float *	mvaInput,
		const pat::Tau &	tau,
		int	mvaOpt,
		const std::string &	nameCharged,
		const std::string &	nameNeutral,
		const std::string &	namePu,
		const std::string &	nameOutside,
		const std::string &	nameFootprint
	)

Definition at line 188 of file PFRecoTauClusterVariables.cc.

References funct::abs(), reco::deltaPhi(), reco::deltaR(), MillePedeFileConverter_cfg::e, eratio(), f, CommonMethods::isnan(), dqmiolumiharvest::j, kDBnewDMwLT, kDBnewDMwLTwGJ, kDBnewDMwLTwGJPhase2, kDBoldDMwLT, kDBoldDMwLTwGJ, kNewDMwLT, kNewDMwoLT, kOldDMwLT, kOldDMwoLT, kPWnewDMwLT, kPWoldDMwLT, dqm-mbProfile::log, SiStripPI::max, SiStripPI::min, taus_updatedMVAIds_cff::mvaOpt, n_photons_total(), l1ctLayer1_cff::nPhoton, conifer::pow(), pt_weighted_deta_strip(), pt_weighted_dphi_strip(), pt_weighted_dr_iso(), pt_weighted_dr_signal(), and mathSSE::sqrt().

Referenced by reco::tau::PATTauDiscriminationByMVAIsolationRun2::discriminate().

                                                              {
      int tauDecayMode = tau.decayMode();
      const float mTau = 1.77682;

      if (((mvaOpt == kOldDMwoLT || mvaOpt == kOldDMwLT || mvaOpt == kDBoldDMwLT || mvaOpt == kPWoldDMwLT ||
            mvaOpt == kDBoldDMwLTwGJ) &&
           (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 10)) ||
          ((mvaOpt == kDBnewDMwLTwGJPhase2 || mvaOpt == kNewDMwoLT || mvaOpt == kNewDMwLT || mvaOpt == kDBnewDMwLT ||
            mvaOpt == kPWnewDMwLT || mvaOpt == kDBnewDMwLTwGJ) &&
           (tauDecayMode == 0 || tauDecayMode == 1 || tauDecayMode == 2 || tauDecayMode == 5 || tauDecayMode == 6 ||
            tauDecayMode == 10 || tauDecayMode == 11))) {
        float chargedIsoPtSum = tau.tauID(nameCharged);
        float neutralIsoPtSum = tau.tauID(nameNeutral);
        float puCorrPtSum = tau.tauID(namePu);
        float photonPtSumOutsideSignalCone = tau.tauID(nameOutside);
        float footprintCorrection = tau.tauID(nameFootprint);

        float decayDistX = tau.flightLength().x();
        float decayDistY = tau.flightLength().y();
        float decayDistZ = tau.flightLength().z();
        float decayDistMag = std::sqrt(decayDistX * decayDistX + decayDistY * decayDistY + decayDistZ * decayDistZ);

        // --- The following 5 variables differ slightly between AOD & MiniAOD
        //     because they are recomputed using packedCandidates saved in the tau
        float nPhoton = reco::tau::n_photons_total(tau);
        float ptWeightedDetaStrip = reco::tau::pt_weighted_deta_strip(tau, tauDecayMode);
        float ptWeightedDphiStrip = reco::tau::pt_weighted_dphi_strip(tau, tauDecayMode);
        float ptWeightedDrSignal = reco::tau::pt_weighted_dr_signal(tau, tauDecayMode);
        float ptWeightedDrIsolation = reco::tau::pt_weighted_dr_iso(tau, tauDecayMode);
        // ---
        float leadingTrackChi2 = tau.leadingTrackNormChi2();
        float eRatio = reco::tau::eratio(tau);

        // Difference between measured and maximally allowed Gottfried-Jackson angle
        float gjAngleDiff = -999;
        if (tauDecayMode == 10) {
          double mAOne = tau.p4().M();
          double pAOneMag = tau.p();
          double argumentThetaGJmax = (std::pow(mTau, 2) - std::pow(mAOne, 2)) / (2 * mTau * pAOneMag);
          double argumentThetaGJmeasured =
              (tau.p4().px() * decayDistX + tau.p4().py() * decayDistY + tau.p4().pz() * decayDistZ) /
              (pAOneMag * decayDistMag);
          if (std::abs(argumentThetaGJmax) <= 1. && std::abs(argumentThetaGJmeasured) <= 1.) {
            double thetaGJmax = std::asin(argumentThetaGJmax);
            double thetaGJmeasured = std::acos(argumentThetaGJmeasured);
            gjAngleDiff = thetaGJmeasured - thetaGJmax;
          }
        }

        if (mvaOpt == kDBnewDMwLTwGJPhase2) {
          mvaInput[0] = tau.pt();
          mvaInput[1] = std::abs(tau.eta());
          mvaInput[2] = chargedIsoPtSum;               //tauID("chargedIsoPtSum");
          mvaInput[3] = neutralIsoPtSum;               //tauID("neutralIsoPtSum");
          mvaInput[4] = puCorrPtSum;                   //tauID("puCorrPtSum");
          mvaInput[5] = photonPtSumOutsideSignalCone;  //tauID("photonPtSumOutsideSignalCone");
          mvaInput[6] = tauDecayMode;                  //tau.decayMode();
          mvaInput[7] = tau.signalGammaCands().size();
          mvaInput[8] = tau.isolationGammaCands().size();

          float sigCands_pt = 0.;
          float sigCands_dr, sigCands_deta, sigCands_dphi;
          sigCands_dr = sigCands_deta = sigCands_dphi = 0.;
          for (const auto& j : tau.signalGammaCands()) {
            const float dr = reco::deltaR(tau, *j);
            const float deta = std::abs(tau.eta() - j->eta());
            const float dphi = std::abs(reco::deltaPhi(tau.phi(), j->phi()));
            const float pt_ = j->pt();
            sigCands_dr += dr * pt_;
            sigCands_deta += deta * pt_;
            sigCands_dphi += dphi * pt_;
            sigCands_pt += pt_;
          }
          if (sigCands_pt > 0.) {
            sigCands_dr = sigCands_dr / sigCands_pt;
            sigCands_deta = sigCands_deta / sigCands_pt;
            sigCands_dphi = sigCands_dphi / sigCands_pt;
          } else {
            sigCands_dr = sigCands_deta = sigCands_dphi = -0.1;
          }
          float isoCands_pt = 0.;
          float isoCands_dr, isoCands_deta, isoCands_dphi;
          isoCands_dr = isoCands_deta = isoCands_dphi = 0.;
          for (const auto& j : tau.isolationGammaCands()) {
            const float dr = reco::deltaR(tau, *j);
            const float deta = std::abs(tau.eta() - j->eta());
            const float dphi = std::abs(reco::deltaPhi(tau.phi(), j->phi()));
            const float pt_ = j->pt();
            isoCands_dr += dr * pt_;
            isoCands_deta += deta * pt_;
            isoCands_dphi += dphi * pt_;
            isoCands_pt += pt_;
          }
          if (isoCands_pt > 0.) {
            isoCands_dr = isoCands_dr / isoCands_pt;
            isoCands_deta = isoCands_deta / isoCands_pt;
            isoCands_dphi = isoCands_dphi / isoCands_pt;
          } else {
            isoCands_dr = isoCands_deta = isoCands_dphi = -0.1;
          }
          mvaInput[9] = isoCands_deta;
          mvaInput[10] = isoCands_dphi;
          mvaInput[11] = isoCands_dr;
          mvaInput[12] = sigCands_deta;
          mvaInput[13] = sigCands_dphi;
          mvaInput[14] = sigCands_dr;

          float e = tau.hcalEnergy() + tau.ecalEnergy();
          e > 0. ? e = tau.ecalEnergy() / e : e = -1.;
          mvaInput[15] = e;
          mvaInput[16] = tau.dxy() >= 0. ? +1 : -1;
          mvaInput[17] = sqrt(std::abs(tau.dxy()));
          mvaInput[18] = std::abs(tau.dxy_Sig());
          mvaInput[19] = tau.ip3d() >= 0. ? +1 : -1;
          mvaInput[20] = sqrt(std::abs(tau.ip3d()));
          mvaInput[21] = std::abs(tau.ip3d_Sig());
          mvaInput[22] = (tau.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput[23] = decayDistMag;  //sqrt(tau.flightLength().Mag2());
          mvaInput[24] = tau.flightLengthSig();
          mvaInput[25] = leadingTrackChi2;  //tau.leadingTrackNormChi2();

          float thetaGJmax, thetaGJ;
          if (decayDistMag > 0. && tau.hasSecondaryVertex()) {
            const float mAOne = tau.p4().M();
            const float pAOneMag = tau.p();
            thetaGJmax = (mTau * mTau - mAOne * mAOne) / (2. * mTau * pAOneMag);
            thetaGJmax = asin(thetaGJmax);
            thetaGJ = (tau.px() * tau.flightLength().x() + tau.py() * tau.flightLength().y() +
                       tau.pz() * tau.flightLength().z()) /
                      (pAOneMag * decayDistMag);
            thetaGJ = acos(thetaGJ);
            if (std::isnan(thetaGJ))
              thetaGJ = -16.;
            if (std::isnan(thetaGJmax))
              thetaGJmax = -11.;
          } else {
            thetaGJ = -15.;
            thetaGJmax = -10.;
          }
          mvaInput[26] = thetaGJ - thetaGJmax;

          mvaInput[27] = 0;
          mvaInput[28] = 10.;
          mvaInput[29] = 10.;
          if (tau.leadChargedHadrCand().isNonnull()) {
            if (tau.leadChargedHadrCand()->bestTrack()) {
              const float trackdxy = tau.leadChargedHadrCand()->bestTrack()->dxy();
              const float trackdxy_err = tau.leadChargedHadrCand()->bestTrack()->dxyError();
              mvaInput[27] = trackdxy >= 0. ? +1 : -1;
              mvaInput[28] = sqrt(std::abs(trackdxy));
              mvaInput[29] = std::abs(trackdxy / trackdxy_err);
            }
          }
        }
        if (mvaOpt == kOldDMwoLT || mvaOpt == kNewDMwoLT) {
          mvaInput[0] = std::log(std::max(1.f, (float)tau.pt()));
          mvaInput[1] = std::abs((float)tau.eta());
          mvaInput[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput[3] = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f * puCorrPtSum));
          mvaInput[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput[5] = tauDecayMode;
        } else if (mvaOpt == kOldDMwLT || mvaOpt == kNewDMwLT) {
          mvaInput[0] = std::log(std::max(1.f, (float)tau.pt()));
          mvaInput[1] = std::abs((float)tau.eta());
          mvaInput[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput[3] = std::log(std::max(1.e-2f, neutralIsoPtSum - 0.125f * puCorrPtSum));
          mvaInput[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput[5] = tauDecayMode;
          mvaInput[6] = std::copysign(+1.f, tau.dxy());
          mvaInput[7] = std::sqrt(std::min(1.f, std::abs(tau.dxy())));
          mvaInput[8] = std::min(10.f, std::abs(tau.dxy_Sig()));
          mvaInput[9] = (tau.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput[10] = std::sqrt(decayDistMag);
          mvaInput[11] = std::min(10.f, tau.flightLengthSig());
        } else if (mvaOpt == kDBoldDMwLT || mvaOpt == kDBnewDMwLT) {
          mvaInput[0] = std::log(std::max(1.f, (float)tau.pt()));
          mvaInput[1] = std::abs((float)tau.eta());
          mvaInput[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput[6] = tauDecayMode;
          mvaInput[7] = std::min(30.f, nPhoton);
          mvaInput[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput[12] = std::min(100.f, leadingTrackChi2);
          mvaInput[13] = std::min(1.f, eRatio);
          mvaInput[14] = std::copysign(+1.f, tau.dxy());
          mvaInput[15] = std::sqrt(std::min(1.f, std::abs(tau.dxy())));
          mvaInput[16] = std::min(10.f, std::abs(tau.dxy_Sig()));
          mvaInput[17] = std::copysign(+1.f, tau.ip3d());
          mvaInput[18] = std::sqrt(std::min(1.f, std::abs(tau.ip3d())));
          mvaInput[19] = std::min(10.f, std::abs(tau.ip3d_Sig()));
          mvaInput[20] = (tau.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput[21] = std::sqrt(decayDistMag);
          mvaInput[22] = std::min(10.f, tau.flightLengthSig());
        } else if (mvaOpt == kPWoldDMwLT || mvaOpt == kPWnewDMwLT) {
          mvaInput[0] = std::log(std::max(1.f, (float)tau.pt()));
          mvaInput[1] = std::abs((float)tau.eta());
          mvaInput[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput[4] = std::log(std::max(1.e-2f, footprintCorrection));
          mvaInput[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput[6] = tauDecayMode;
          mvaInput[7] = std::min(30.f, nPhoton);
          mvaInput[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput[12] = std::min(100.f, leadingTrackChi2);
          mvaInput[13] = std::min(1.f, eRatio);
          mvaInput[14] = std::copysign(+1.f, tau.dxy());
          mvaInput[15] = std::sqrt(std::min(1.f, std::abs(tau.dxy())));
          mvaInput[16] = std::min(10.f, std::abs(tau.dxy_Sig()));
          mvaInput[17] = std::copysign(+1.f, tau.ip3d());
          mvaInput[18] = std::sqrt(std::min(1.f, std::abs(tau.ip3d())));
          mvaInput[19] = std::min(10.f, std::abs(tau.ip3d_Sig()));
          mvaInput[20] = (tau.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput[21] = std::sqrt(decayDistMag);
          mvaInput[22] = std::min(10.f, tau.flightLengthSig());
        } else if (mvaOpt == kDBoldDMwLTwGJ || mvaOpt == kDBnewDMwLTwGJ) {
          mvaInput[0] = std::log(std::max(1.f, (float)tau.pt()));
          mvaInput[1] = std::abs((float)tau.eta());
          mvaInput[2] = std::log(std::max(1.e-2f, chargedIsoPtSum));
          mvaInput[3] = std::log(std::max(1.e-2f, neutralIsoPtSum));
          mvaInput[4] = std::log(std::max(1.e-2f, puCorrPtSum));
          mvaInput[5] = std::log(std::max(1.e-2f, photonPtSumOutsideSignalCone));
          mvaInput[6] = tauDecayMode;
          mvaInput[7] = std::min(30.f, nPhoton);
          mvaInput[8] = std::min(0.5f, ptWeightedDetaStrip);
          mvaInput[9] = std::min(0.5f, ptWeightedDphiStrip);
          mvaInput[10] = std::min(0.5f, ptWeightedDrSignal);
          mvaInput[11] = std::min(0.5f, ptWeightedDrIsolation);
          mvaInput[12] = std::min(1.f, eRatio);
          mvaInput[13] = std::copysign(+1.f, tau.dxy());
          mvaInput[14] = std::sqrt(std::min(1.f, std::abs(tau.dxy())));
          mvaInput[15] = std::min(10.f, std::abs(tau.dxy_Sig()));
          mvaInput[16] = std::copysign(+1.f, tau.ip3d());
          mvaInput[17] = std::sqrt(std::min(1.f, std::abs(tau.ip3d())));
          mvaInput[18] = std::min(10.f, std::abs(tau.ip3d_Sig()));
          mvaInput[19] = (tau.hasSecondaryVertex()) ? 1. : 0.;
          mvaInput[20] = std::sqrt(decayDistMag);
          mvaInput[21] = std::min(10.f, tau.flightLengthSig());
          mvaInput[22] = std::max(-1.f, gjAngleDiff);
        }

        return true;
      }
      return false;
    }

filterPFCandidates()

template<typename Iterator >

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

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

Definition at line 41 of file RecoTauCommonUtilities.h.

References funct::abs(), convertSQLitetoXML_cfg::output, EgammaValidation_cff::pdgId, and jetUpdater_cfi::sort.

Referenced by pfCandidatesByPdgId(), and pfChargedCands().

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

flattenPiZeros() [1/2]

std::vector< CandidatePtr > 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 43 of file RecoTauCommonUtilities.cc.

References convertSQLitetoXML_cfg::output.

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

                                                                                                       {
      std::vector<CandidatePtr> output;

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

flattenPiZeros() [2/2]

std::vector< CandidatePtr > reco::tau::flattenPiZeros

(

const std::vector< RecoTauPiZero > &

piZeros

)

Definition at line 55 of file RecoTauCommonUtilities.cc.

References flattenPiZeros().

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

format_vint()

std::string reco::tau::format_vint

(

const std::vector< int > &

vi

)

Definition at line 33 of file RecoTauMuonTools.cc.

References edm::numEntries().

                                                    {
      std::ostringstream os;
      os << "{ ";
      unsigned numEntries = vi.size();
      for (unsigned iEntry = 0; iEntry < numEntries; ++iEntry) {
        os << vi[iEntry];
        if (iEntry < (numEntries - 1))
          os << ", ";
      }
      os << " }";
      return os.str();
    }

getDecayMode()

PFTau::hadronicDecayMode reco::tau::getDecayMode

(

const reco::GenJet *

genJet

)

Definition at line 78 of file PFTauDecayModeTools.cc.

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

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

getTrackFromChargedHadron()

const reco::Track * reco::tau::getTrackFromChargedHadron

(

const reco::PFRecoTauChargedHadron &

chargedHadron

)

Definition at line 12 of file pfRecoTauChargedHadronAuxFunctions.cc.

References pat::PackedCandidate::bestTrack(), and HPSPFTauProducerPuppi_cfi::chargedHadron.

Referenced by reco::tau::RecoTauSoftTwoProngTausCleanerPlugin::operator()(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), PFRecoTauChargedHadronProducer::produce(), and setChargedHadronP4().

                                                                                                {
      // Charged hadron made from track (reco::Track) - RECO/AOD only
      if (chargedHadron.getTrack().isNonnull()) {
        return chargedHadron.getTrack().get();
      }
      // In MiniAOD, even isolated tracks are saved as candidates, so the track Ptr doesn't exist
      const pat::PackedCandidate* chargedPFPCand =
          dynamic_cast<const pat::PackedCandidate*>(chargedHadron.getChargedPFCandidate().get());
      if (chargedPFPCand != nullptr) {
        return chargedPFPCand->bestTrack();
      }
      const pat::PackedCandidate* lostTrackCand =
          dynamic_cast<const pat::PackedCandidate*>(chargedHadron.getLostTrackCandidate().get());
      if (lostTrackCand != nullptr) {
        return lostTrackCand->bestTrack();
      }
      return nullptr;
    }

isPtrEqual() [1/2]

template<class Base , class Der >

bool reco::tau::isPtrEqual	(	const edm::Ptr< Base > &	b,
		const edm::Ptr< Der > &	d
	)

Definition at line 94 of file PFRecoTauEnergyAlgorithmPlugin.cc.

References b, and ztail::d.

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

                                                                 {
      return edm::Ptr<Der>(b) == d;
    }

isPtrEqual() [2/2]

template<class Base >

bool reco::tau::isPtrEqual	(	const edm::Ptr< Base > &	b,
		const edm::Ptr< Base > &	d
	)

Definition at line 99 of file PFRecoTauEnergyAlgorithmPlugin.cc.

References b, and ztail::d.

                                                                  {
      return b == d;
    }

lead_track_chi2()

float reco::tau::lead_track_chi2

(

const reco::PFTau &

tau

)

return chi2 of the leading track ==> deprecated? <==

Definition at line 58 of file PFRecoTauClusterVariables.cc.

References edm::Ptr< T >::get(), pat::PackedCandidate::hasTrackDetails(), edm::Ptr< T >::isNonnull(), edm::Ref< C, T, F >::isNonnull(), reco::TrackBase::normalizedChi2(), pfDeepBoostedJetPreprocessParams_cfi::pfcand, and pat::PackedCandidate::pseudoTrack().

Referenced by reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate().

                                                {
      float LeadingTracknormalizedChi2 = 0;
      const reco::CandidatePtr& leadingCharged = tau.leadChargedHadrCand();
      if (leadingCharged.isNonnull()) {
        const reco::PFCandidate* pfcand = dynamic_cast<const reco::PFCandidate*>(leadingCharged.get());
        if (pfcand != nullptr) {
          reco::TrackRef tref = pfcand->trackRef();
          if (tref.isNonnull()) {
            LeadingTracknormalizedChi2 = tref->normalizedChi2();
          }
        } else {
          const pat::PackedCandidate* patcand = dynamic_cast<const pat::PackedCandidate*>(leadingCharged.get());
          if (patcand != nullptr && patcand->hasTrackDetails()) {
            LeadingTracknormalizedChi2 = patcand->pseudoTrack().normalizedChi2();
          }
        }
      }
      return LeadingTracknormalizedChi2;
    }

leadCand()

template<typename InputIterator >

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

Definition at line 138 of file RecoTauCommonUtilities.h.

Referenced by reco::tau::RecoTauConstructor::get(), reco::tau::RecoTauVertexAssociator::getLeadCand(), reco::tau::RecoTauVertexAssociator::getLeadTrack(), reco::tau::RecoTauVertexAssociator::getLeadTrackRef(), and reco::tau::RecoTauQualityCuts::setLeadTrack().

                                                                   {
      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;
    }

n_photons_total() [1/2]

unsigned int reco::tau::n_photons_total

(

const reco::PFTau &

tau

)

return total number of pf photon candidates with pT>500 MeV, which are associated to signal

Definition at line 163 of file PFRecoTauClusterVariables.cc.

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

                                                       {
      unsigned int n_photons = 0;
      for (auto& cand : tau.signalGammaCands()) {
        if (cand->pt() > 0.5)
          ++n_photons;
      }
      for (auto& cand : tau.isolationGammaCands()) {
        if (cand->pt() > 0.5)
          ++n_photons;
      }
      return n_photons;
    }

n_photons_total() [2/2]

unsigned int reco::tau::n_photons_total

(

const pat::Tau &

tau

)

Definition at line 175 of file PFRecoTauClusterVariables.cc.

                                                    {
      unsigned int n_photons = 0;
      for (auto& cand : tau.signalGammaCands()) {
        if (cand->pt() > 0.5)
          ++n_photons;
      }
      for (auto& cand : tau.isolationGammaCands()) {
        if (cand->pt() > 0.5)
          ++n_photons;
      }
      return n_photons;
    }

pfCandidates() [1/2]

std::vector< reco::CandidatePtr > reco::tau::pfCandidates	(	const Jet &	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. Internally translates to pdgId

Definition at line 59 of file RecoTauCommonUtilities.cc.

References metsig::jet, pfCandidatesByPdgId(), and jetUpdater_cfi::sort.

Referenced by reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin::operator()(), reco::tau::RecoTauPiZeroStripPlugin2::operator()(), reco::tau::RecoTauPiZeroStripPlugin3::operator()(), and pfGammas().

                                                                                            {
      return pfCandidatesByPdgId(jet, translateTypeToAbsPdgId(particleId), sort);
    }

pfCandidates() [2/2]

std::vector< CandidatePtr > reco::tau::pfCandidates	(	const Jet &	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 63 of file RecoTauCommonUtilities.cc.

References metsig::jet, CosmicGenFilterHelix_cfi::pdgIds, pfCandidatesByPdgId(), and jetUpdater_cfi::sort.

                                                                                                       {
      std::vector<int> pdgIds;
      pdgIds.reserve(particleIds.size());
      for (auto particleId : particleIds)
        pdgIds.push_back(translateTypeToAbsPdgId(particleId));
      return pfCandidatesByPdgId(jet, pdgIds, sort);
    }

pfCandidatesByPdgId() [1/2]

std::vector< reco::CandidatePtr > reco::tau::pfCandidatesByPdgId	(	const Jet &	jet,
		int	pdgId,
		bool	sort = true
	)

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

Definition at line 71 of file RecoTauCommonUtilities.cc.

References filterPFCandidates(), metsig::jet, EgammaValidation_cff::pdgId, and jetUpdater_cfi::sort.

Referenced by PATTauHybridProducer::fillTauFromJet(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), reco::tau::RecoTauBuilderConePlugin::operator()(), and pfCandidates().

                                                                                              {
      CandPtrs pfCands = jet.daughterPtrVector();
      CandPtrs selectedPFCands = filterPFCandidates(pfCands.begin(), pfCands.end(), pdgId, sort);
      return selectedPFCands;
    }

pfCandidatesByPdgId() [2/2]

std::vector< reco::CandidatePtr > reco::tau::pfCandidatesByPdgId	(	const Jet &	jet,
		const std::vector< int > &	pdgIds,
		bool	sort = true
	)

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

Definition at line 77 of file RecoTauCommonUtilities.cc.

References filterPFCandidates(), metsig::jet, convertSQLitetoXML_cfg::output, EgammaValidation_cff::pdgId, CosmicGenFilterHelix_cfi::pdgIds, and jetUpdater_cfi::sort.

                                                                   {
      const CandPtrs& pfCands = jet.daughterPtrVector();
      CandPtrs output;
      // Get each desired candidate type, unsorted for now
      for (std::vector<int>::const_iterator pdgId = pdgIds.begin(); pdgId != pdgIds.end(); ++pdgId) {
        CandPtrs&& selectedPFCands = filterPFCandidates(pfCands.begin(), pfCands.end(), *pdgId, false);
        output.insert(output.end(), selectedPFCands.begin(), selectedPFCands.end());
      }
      if (sort)
        std::sort(output.begin(), output.end(), SortPFCandsDescendingPt());
      return output;
    }

pfChargedCands()

std::vector< reco::CandidatePtr > reco::tau::pfChargedCands	(	const Jet &	jet,
		bool	sort = true
	)

Extract all non-neutral candidates from a PFJet.

Definition at line 94 of file RecoTauCommonUtilities.cc.

References filterPFCandidates(), metsig::jet, convertSQLitetoXML_cfg::output, and jetUpdater_cfi::sort.

Referenced by PATTauHybridProducer::fillTauFromJet(), reco::tau::RecoTauVertexAssociator::getLeadCand(), reco::tau::RecoTauBuilderCombinatoricPlugin::operator()(), and reco::tau::RecoTauBuilderConePlugin::operator()().

                                                                              {
      const CandPtrs& pfCands = jet.daughterPtrVector();
      CandPtrs output;
      CandPtrs&& mus = filterPFCandidates(pfCands.begin(), pfCands.end(), 13, false);
      CandPtrs&& es = filterPFCandidates(pfCands.begin(), pfCands.end(), 11, false);
      CandPtrs&& chs = filterPFCandidates(pfCands.begin(), pfCands.end(), 211, 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;
    }

pfGammas()

std::vector< reco::CandidatePtr > reco::tau::pfGammas	(	const Jet &	jet,
		bool	sort = true
	)

Extract all pfGammas from a PFJet.

Definition at line 92 of file RecoTauCommonUtilities.cc.

References metsig::jet, pfCandidates(), and jetUpdater_cfi::sort.

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

{ return pfCandidates(jet, 22, sort); }

piZerosInDecayMode()

unsigned int reco::tau::piZerosInDecayMode

(

PFTau::hadronicDecayMode

mode

)

Definition at line 49 of file PFTauDecayModeTools.cc.

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

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

pt_weighted_deta_strip() [1/2]

float reco::tau::pt_weighted_deta_strip ( const reco::PFTau &  tau, int  dm  )

inline

return sum of pt weighted values of deta relative to tau candidate for all pf photon candidates, which are associated to signal

Definition at line 36 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

                                                                      {
      return pt_weighted_dx(tau, dm == 10 ? 2 : 1, 1, dm);
    }

pt_weighted_deta_strip() [2/2]

float reco::tau::pt_weighted_deta_strip ( const pat::Tau &  tau, int  dm  )

inline

Definition at line 39 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

                                                                   {
      return pt_weighted_dx(tau, dm == 10 ? 2 : 1, 1, dm);
    }

pt_weighted_dphi_strip() [1/2]

float reco::tau::pt_weighted_dphi_strip ( const reco::PFTau &  tau, int  dm  )

inline

return sum of pt weighted values of dphi relative to tau candidate for all pf photon candidates, which are associated to signal

Definition at line 44 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

                                                                      {
      return pt_weighted_dx(tau, dm == 10 ? 2 : 1, 2, dm);
    }

pt_weighted_dphi_strip() [2/2]

float reco::tau::pt_weighted_dphi_strip ( const pat::Tau &  tau, int  dm  )

inline

Definition at line 47 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

                                                                   {
      return pt_weighted_dx(tau, dm == 10 ? 2 : 1, 2, dm);
    }

pt_weighted_dr_iso() [1/2]

float reco::tau::pt_weighted_dr_iso ( const reco::PFTau &  tau, int  dm  )

inline

return sum of pt weighted values of dr relative to tau candidate for all pf photon candidates, which are inside an isolation conde but not associated to signal

Definition at line 52 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

{ return pt_weighted_dx(tau, 2, 0, dm); }

pt_weighted_dr_iso() [2/2]

float reco::tau::pt_weighted_dr_iso ( const pat::Tau &  tau, int  dm  )

inline

Definition at line 53 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

{ return pt_weighted_dx(tau, 2, 0, dm); }

pt_weighted_dr_signal() [1/2]

float reco::tau::pt_weighted_dr_signal ( const reco::PFTau &  tau, int  dm  )

inline

return sum of pt weighted values of dr relative to tau candidate for all pf photon candidates, which are associated to signal

Definition at line 32 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

Referenced by DeepTauId::createTauBlockInputs(), reco::tau::PFRecoTauDiscriminationByMVAIsolationRun2::discriminate(), and fillIsoMVARun2Inputs().

{ return pt_weighted_dx(tau, 0, 0, dm); }

pt_weighted_dr_signal() [2/2]

float reco::tau::pt_weighted_dr_signal ( const pat::Tau &  tau, int  dm  )

inline

Definition at line 33 of file PFRecoTauClusterVariables.h.

References symbols::dm, and pt_weighted_dx().

{ return pt_weighted_dx(tau, 0, 0, dm); }

pt_weighted_dx() [1/2]

float reco::tau::pt_weighted_dx	(	const reco::PFTau &	tau,
		int	mode = 0,
		int	var = 0,
		int	decaymode = -1
	)

return sum of pt weighted values of distance to tau candidate for all pf photon candidates, which are associated to signal; depending on var the distance is in 0=:dr, 1=:deta, 2=:dphi

Definition at line 156 of file PFRecoTauClusterVariables.cc.

References runTauDisplay::decaymode, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, metsig::tau, and trigObjTnPSource_cfi::var.

Referenced by pt_weighted_deta_strip(), pt_weighted_dphi_strip(), pt_weighted_dr_iso(), and pt_weighted_dr_signal().

                                                                                 {
      return pt_weighted_dx_T<PFTau_traits>(tau, mode, var, decaymode);
    }

pt_weighted_dx() [2/2]

float reco::tau::pt_weighted_dx	(	const pat::Tau &	tau,
		int	mode = 0,
		int	var = 0,
		int	decaymode = -1
	)

Definition at line 159 of file PFRecoTauClusterVariables.cc.

References runTauDisplay::decaymode, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, metsig::tau, and trigObjTnPSource_cfi::var.

                                                                              {
      return pt_weighted_dx_T<PATTau_traits>(tau, mode, var, decaymode);
    }

pt_weighted_dx_T()

template<typename T >

float reco::tau::pt_weighted_dx_T	(	const typename T::Tau_t &	tau,
		int	mode,
		int	var,
		int	decaymode
	)

return sum of pt weighted values of distance to tau candidate for all pf photon candidates, which are associated to signal; depending on var the distance is in 0=:dr, 1=:deta, 2=:dphi

Definition at line 113 of file PFRecoTauClusterVariables.cc.

References funct::abs(), HLT_2023v12_cff::cands, runTauDisplay::decaymode, reco::deltaPhi(), reco::deltaR(), RemoveAddSevLevel::flag, SiStripPI::max, SiStripPI::min, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, DiDispStaMuonMonitor_cfi::pt, metsig::tau, and trigObjTnPSource_cfi::var.

                                                                                         {
      float sum_pt = 0.;
      float sum_dx_pt = 0.;
      float signalrad = std::max(0.05, std::min(0.1, 3. / std::max(1., tau.pt())));
      int is3prong = (decaymode == 10);
      const auto& cands = getGammas_T<T>(tau, mode < 2);
      for (const auto& cand : cands) {
        // only look at electrons/photons with pT > 0.5
        if (cand->pt() < 0.5) {
          continue;
        }
        float dr = reco::deltaR(cand->eta(), cand->phi(), tau.eta(), tau.phi());
        float deta = std::abs(cand->eta() - tau.eta());
        float dphi = std::abs(reco::deltaPhi(cand->phi(), tau.phi()));
        float pt = cand->pt();
        bool flag = isInside(pt, deta, dphi);
        if (is3prong == 0) {
          if (mode == 2 || (mode == 0 && dr < signalrad) || (mode == 1 && dr > signalrad)) {
            sum_pt += pt;
            if (var == 0)
              sum_dx_pt += pt * dr;
            else if (var == 1)
              sum_dx_pt += pt * deta;
            else if (var == 2)
              sum_dx_pt += pt * dphi;
          }
        } else if (is3prong == 1) {
          if ((mode == 2 && flag == false) || (mode == 1 && flag == true) || mode == 0) {
            sum_pt += pt;
            if (var == 0)
              sum_dx_pt += pt * dr;
            else if (var == 1)
              sum_dx_pt += pt * deta;
            else if (var == 2)
              sum_dx_pt += pt * dphi;
          }
        }
      }
      if (sum_pt > 0.) {
        return sum_dx_pt / sum_pt;
      }
      return 0.;
    }

s_filler_0__LINE__() [1/2]

static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker<edm::ParameterSetDescriptionFiller< PATTauDiscriminationByMVAIsolationRun2 > > reco::tau::s_filler_0__LINE__ ( "PATTauDiscriminationByMVAIsolationRun2"  )

static

s_filler_0__LINE__() [2/2]

static const edm::ParameterSetDescriptionFillerPluginFactory::PMaker<edm::ParameterSetDescriptionFiller< PFRecoTauDiscriminationByMVAIsolationRun2 > > reco::tau::s_filler_0__LINE__ ( "PFRecoTauDiscriminationByMVAIsolationRun2"  )

static

s_maker__LINE__() [1/2]

static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< PATTauDiscriminationByMVAIsolationRun2 > > reco::tau::s_maker__LINE__ ( "PATTauDiscriminationByMVAIsolationRun2"  )

static

s_maker__LINE__() [2/2]

static const edm::MakerPluginFactory ::PMaker< edm::WorkerMaker< PFRecoTauDiscriminationByMVAIsolationRun2 > > reco::tau::s_maker__LINE__ ( "PFRecoTauDiscriminationByMVAIsolationRun2"  )

static

setChargedHadronP4()

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

Definition at line 31 of file pfRecoTauChargedHadronAuxFunctions.cc.

References cms::cuda::assert(), HPSPFTauProducerPuppi_cfi::chargedHadron, compChargedHadronP4fromPxPyPz(), getTrackFromChargedHadron(), edm::Ptr< T >::isNonnull(), reco::PFRecoTauChargedHadron::kChargedPFCandidate, reco::PFRecoTauChargedHadron::kPFNeutralHadron, reco::PFRecoTauChargedHadron::kTrack, electrons_cff::ptRatio, and HLT_2023v12_cff::track.

Referenced by reco::tau::RecoTauConstructor::addTauChargedHadron(), reco::tau::PFRecoTauEnergyAlgorithmPlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromPFCandidatePlugin::operator()(), reco::tau::PFRecoTauChargedHadronFromGenericTrackPlugin< TrackClass >::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::CandidatePtr& 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::Track* track = getTrackFromChargedHadron(chargedHadron);
        if (track != nullptr) {
          chargedHadronP += track->p();
          chargedHadronPx = track->px();
          chargedHadronPy = track->py();
          chargedHadronPz = track->pz();
        } else {  // lost tracks from MiniAOD that don't have track information saved
          const reco::CandidatePtr& lostTrack = chargedHadron.getLostTrackCandidate();
          assert(lostTrack.isNonnull());
          chargedHadronP += lostTrack->p();
          chargedHadronPx = lostTrack->px();
          chargedHadronPy = lostTrack->py();
          chargedHadronPz = lostTrack->pz();
        }
      } else
        assert(0);
      const std::vector<reco::CandidatePtr>& neutralPFCands = chargedHadron.getNeutralPFCandidates();
      for (std::vector<reco::CandidatePtr>::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);
    }

sumPFCandCharge()

template<typename InputIterator >

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

Sum the charge of a collection of PFCandidates.

Definition at line 133 of file RecoTauCommonUtilities.h.

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

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

sumPFCandP4()

template<typename InputIterator >

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

Definition at line 121 of file RecoTauCommonUtilities.h.

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

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

sumPFCandPt()

template<typename InputIterator >

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

Sum the pT of a collection of PFCandidates.

Definition at line 127 of file RecoTauCommonUtilities.h.

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

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

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

sumPFVector()

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 111 of file RecoTauCommonUtilities.h.

References EcalMonitorTask_cff::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;
    }

takeNElements()

template<typename InputIterator >

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

Definition at line 104 of file RecoTauCommonUtilities.h.

References N.

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

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

translateDecayMode()

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

Definition at line 54 of file PFTauDecayModeTools.cc.

References reco::PFTau::kNull, reco::PFTau::kOneProngNPiZero, reco::PFTau::kRareDecayMode, HLT_2023v12_cff::maxPiZeros, HLT_2023v12_cff::nCharged, and HLT_2023v12_cff::nPiZeros.

                                                                                            {
      // 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);
    }

translateGenDecayModeToReco()

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.

References Skims_PA_cff::name.

Referenced by getDecayMode().

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

translateRecoDecayModeToGen()

std::string reco::tau::translateRecoDecayModeToGen

(

PFTau::hadronicDecayMode

decayMode

)

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

Definition at line 74 of file PFTauDecayModeTools.cc.

References boostedTaus_cff::decayMode.

                                                                            {
      return decayModeIdToString(decayMode, dmTranslatorMap);
    }