PFRecoTauDiscriminationByHPSSelection Class Reference

Inheritance diagram for PFRecoTauDiscriminationByHPSSelection:

Classes
struct	DecayModeCuts

Public Member Functions
double	discriminate (const reco::PFTauRef &) const override
	PFRecoTauDiscriminationByHPSSelection (const edm::ParameterSet &)
	~PFRecoTauDiscriminationByHPSSelection () override
Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
virtual void	beginEvent (const edm::Event &, const edm::EventSetup &)
virtual TauDiscriminatorDataType	discriminate (const TauRef &tau) const =0
virtual void	endEvent (edm::Event &)
void	produce (edm::Event &, const edm::EventSetup &) override
	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
	TauDiscriminationProducerBase ()
	~TauDiscriminationProducerBase () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)
static std::string	getTauTypeString ()
	helper method to retrieve tau type name, e.g. to build correct cfi getter More...

Private Types
typedef std::map< IntPair, DecayModeCuts >	DecayModeCutMap
typedef std::pair< double, double >	DoublePair
typedef std::pair< unsigned int, unsigned int >	IntPair
typedef StringObjectFunction< reco::PFTau >	TauFunc

Private Attributes
DecayModeCutMap	decayModeCuts_
double	matchingCone_
int	minPixelHits_
double	minPt_
bool	requireTauChargedHadronsToBeChargedPFCands_
int	verbosity_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
typedef std::vector< TauType >	TauCollection
typedef edm::Ref< TauCollection >	TauRef
typedef edm::RefProd< TauCollection >	TauRefProd
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
std::string	moduleLabel_
double	prediscriminantFailValue_
edm::EDGetTokenT< TauCollection >	Tau_token
size_t	tauIndex_
edm::InputTag	TauProducer_

Detailed Description

Definition at line 22 of file PFRecoTauDiscriminationByHPSSelection.cc.

Member Typedef Documentation

DecayModeCutMap

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

private

Definition at line 50 of file PFRecoTauDiscriminationByHPSSelection.cc.

DoublePair

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

private

Definition at line 49 of file PFRecoTauDiscriminationByHPSSelection.cc.

IntPair

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

private

Definition at line 48 of file PFRecoTauDiscriminationByHPSSelection.cc.

TauFunc

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

private

Definition at line 31 of file PFRecoTauDiscriminationByHPSSelection.cc.

Constructor & Destructor Documentation

PFRecoTauDiscriminationByHPSSelection()

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

explicit

Definition at line 63 of file PFRecoTauDiscriminationByHPSSelection.cc.

References HLT_2023v12_cff::applyBendCorrection, boostedTaus_cff::decayMode, decayModeCuts_, HLT_2023v12_cff::decayModes, matchingCone_, minPixelHits_, minPt_, muonDTDigis_cfi::pset, requireTauChargedHadronsToBeChargedPFCands_, AlCaHLTBitMon_QueryRunRegistry::string, verbosity_, and HistogramManager_cfi::VPSet().

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

~PFRecoTauDiscriminationByHPSSelection()

PFRecoTauDiscriminationByHPSSelection::~PFRecoTauDiscriminationByHPSSelection ( )

override

Definition at line 95 of file PFRecoTauDiscriminationByHPSSelection.cc.

References decayModeCuts_.

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

Member Function Documentation

discriminate()

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

override

Definition at line 120 of file PFRecoTauDiscriminationByHPSSelection.cc.

References funct::abs(), PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_eta_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_phi_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, HPSPFTauProducerPuppi_cfi::chargedHadron, pfMETCorrectionType0_cfi::correction, decayModeCuts_, reco::deltaPhi(), PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2023v12_cff::dEta, HLT_2023v12_cff::dPhi, getTrack(), reco::PFRecoTauChargedHadron::kChargedPFCandidate, reco::PFRecoTauChargedHadron::kPFNeutralHadron, reco::PFRecoTauChargedHadron::kTrack, matchingCone_, SiStripPI::max, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxPi0Mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minPi0Mass_, minPixelHits_, minPt_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nChargedPFCandsMin_, beamSpotPI::nTracks, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nTracksMin_, requireTauChargedHadronsToBeChargedPFCands_, AlCaHLTBitMon_QueryRunRegistry::string, metsig::tau, HLT_2023v12_cff::track, and verbosity_.

                                                                                        {
  if (verbosity_) {
    edm::LogPrint("PFTauByHPSSelect") << "<PFRecoTauDiscriminationByHPSSelection::discriminate>:";
    edm::LogPrint("PFTauByHPSSelect") << " nCharged = " << tau->signalTauChargedHadronCandidates().size();
    edm::LogPrint("PFTauByHPSSelect") << " nPiZeros = " << tau->signalPiZeroCandidates().size();
  }

  // Check if we pass the min pt
  if (tau->pt() < minPt_) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails minPt cut.";
    }
    return 0.0;
  }

  // See if we select this decay mode
  DecayModeCutMap::const_iterator massWindowIter = decayModeCuts_.find(
      std::make_pair(tau->signalTauChargedHadronCandidates().size(), tau->signalPiZeroCandidates().size()));
  // Check if decay mode is supported
  if (massWindowIter == decayModeCuts_.end()) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails mass-window definition requirement.";
    }
    return 0.0;
  }
  const DecayModeCuts& massWindow = massWindowIter->second;

  if (massWindow.nTracksMin_ > 0) {
    unsigned int nTracks = 0;
    const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
    for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
         chargedHadron != chargedHadrons.end();
         ++chargedHadron) {
      if (chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate) ||
          chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kTrack)) {
        ++nTracks;
      }
    }
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << "nTracks = " << nTracks << " (min = " << massWindow.nTracksMin_ << ")";
    }
    if (nTracks < massWindow.nTracksMin_) {
      if (verbosity_) {
        edm::LogPrint("PFTauByHPSSelect") << " fails nTracks requirement for mass-window.";
      }
      return 0.0;
    }
  }
  if (massWindow.nChargedPFCandsMin_ > 0) {
    unsigned int nChargedPFCands = 0;
    const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
    for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
         chargedHadron != chargedHadrons.end();
         ++chargedHadron) {
      if (chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate)) {
        ++nChargedPFCands;
      }
    }
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << "nChargedPFCands = " << nChargedPFCands
                                        << " (min = " << massWindow.nChargedPFCandsMin_ << ")";
    }
    if (nChargedPFCands < massWindow.nChargedPFCandsMin_) {
      if (verbosity_) {
        edm::LogPrint("PFTauByHPSSelect") << " fails nChargedPFCands requirement for mass-window.";
      }
      return 0.0;
    }
  }

  math::XYZTLorentzVector tauP4 = tau->p4();
  if (verbosity_) {
    edm::LogPrint("PFTauByHPSSelect") << "tau: Pt = " << tauP4.pt() << ", eta = " << tauP4.eta()
                                      << ", phi = " << tauP4.phi() << ", mass = " << tauP4.mass();
  }
  // Find the total pizero p4
  reco::Candidate::LorentzVector stripsP4;
  for (auto const& cand : tau->signalPiZeroCandidates()) {
    const math::XYZTLorentzVector& candP4 = cand.p4();
    stripsP4 += candP4;
  }

  // Apply strip mass assumption corrections
  if (massWindow.assumeStripMass_ >= 0) {
    for (auto const& cand : tau->signalPiZeroCandidates()) {
      const math::XYZTLorentzVector& uncorrected = cand.p4();
      math::XYZTLorentzVector corrected = applyMassConstraint(uncorrected, massWindow.assumeStripMass_);
      math::XYZTLorentzVector correction = corrected - uncorrected;
      tauP4 += correction;
      stripsP4 += correction;
    }
  }
  if (verbosity_) {
    edm::LogPrint("PFTauByHPSSelect") << "strips: Pt = " << stripsP4.pt() << ", eta = " << stripsP4.eta()
                                      << ", phi = " << stripsP4.phi() << ", mass = " << stripsP4.mass();
  }

  // Check if tau fails mass cut
  double maxMass_value = (*massWindow.maxMass_)(*tau);
  double bendCorrection_mass = (massWindow.applyBendCorrection_mass_) ? tau->bendCorrMass() : 0.;
  if (!((tauP4.M() - bendCorrection_mass) < maxMass_value && (tauP4.M() + bendCorrection_mass) > massWindow.minMass_)) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut.";
    }
    return 0.0;
  }
  // CV: require that mass of charged tau decay products is always within specified mass window,
  //     irrespective of bendCorrection_mass
  reco::Candidate::LorentzVector tauP4_charged;
  const std::vector<reco::PFRecoTauChargedHadron>& signalChargedHadrons = tau->signalTauChargedHadronCandidates();
  for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator signalChargedHadron = signalChargedHadrons.begin();
       signalChargedHadron != signalChargedHadrons.end();
       ++signalChargedHadron) {
    tauP4_charged += signalChargedHadron->p4();
  }
  if (!(tauP4_charged.mass() < maxMass_value)) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut.";
    }
    return 0.0;
  }

  // Check if it fails the pi0 IM cut
  if (stripsP4.M() > massWindow.maxPi0Mass_ || stripsP4.M() < massWindow.minPi0Mass_) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails strip mass-window cut.";
    }
    return 0.0;
  }

  // Check if tau passes matching cone cut
  //edm::LogPrint("PFTauByHPSSelect") << "dR(tau, jet) = " << deltaR(tauP4, tau->jetRef()->p4()) ;
  if (deltaR(tauP4, tau->jetRef()->p4()) > matchingCone_) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << " fails matching-cone cut.";
    }
    return 0.0;
  }

  // Check if tau passes cone cut
  double cone_size = tau->signalConeSize();
  // Check if any charged objects fail the signal cone cut
  for (auto const& cand : tau->signalTauChargedHadronCandidates()) {
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << "dR(tau, signalPFChargedHadr) = " << deltaR(cand.p4(), tauP4);
    }
    if (deltaR(cand.p4(), tauP4) > cone_size) {
      if (verbosity_) {
        edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for charged hadron(s).";
      }
      return 0.0;
    }
  }
  // Now check the pizeros
  for (auto const& cand : tau->signalPiZeroCandidates()) {
    double bendCorrection_eta = (massWindow.applyBendCorrection_eta_) ? cand.bendCorrEta() : 0.;
    double dEta = std::max(0., fabs(cand.eta() - tauP4.eta()) - bendCorrection_eta);
    double bendCorrection_phi = (massWindow.applyBendCorrection_phi_) ? cand.bendCorrPhi() : 0.;
    double dPhi = std::max(0., std::abs(reco::deltaPhi(cand.phi(), tauP4.phi())) - bendCorrection_phi);
    double dR2 = dEta * dEta + dPhi * dPhi;
    if (verbosity_) {
      edm::LogPrint("PFTauByHPSSelect") << "dR2(tau, signalPiZero) = " << dR2;
    }
    if (dR2 > cone_size * cone_size) {
      if (verbosity_) {
        edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for strip(s).";
      }
      return 0.0;
    }
  }

  if (requireTauChargedHadronsToBeChargedPFCands_) {
    for (auto const& cand : tau->signalTauChargedHadronCandidates()) {
      if (verbosity_) {
        std::string algo_string;
        if (cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate)
          algo_string = "ChargedPFCandidate";
        else if (cand.algo() == reco::PFRecoTauChargedHadron::kTrack)
          algo_string = "Track";
        else if (cand.algo() == reco::PFRecoTauChargedHadron::kPFNeutralHadron)
          algo_string = "PFNeutralHadron";
        else
          algo_string = "Undefined";
        edm::LogPrint("PFTauByHPSSelect") << "algo(signalPFChargedHadr) = " << algo_string;
      }
      if (!(cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate)) {
        if (verbosity_) {
          edm::LogPrint("PFTauByHPSSelect") << " fails cut on PFRecoTauChargedHadron algo.";
        }
        return 0.0;
      }
    }
  }

  if (minPixelHits_ > 0) {
    int numPixelHits = 0;
    const int nProngs = tau->decayMode() / 5 + 1;  //no. of charged prongs expected for this tau
    int nTracks = 0;
    for (const auto& chargedHadrCand : tau->signalChargedHadrCands()) {
      const reco::Track* track = getTrack(*chargedHadrCand);
      if (track != nullptr) {
        numPixelHits += track->hitPattern().numberOfValidPixelHits();
        nTracks++;
      }
    }
    //MB: how to deal with tau@miniAOD case?
    if (nTracks < nProngs) {  //"lost track" probably used to build this tau
      for (const auto& track : tau->signalTracks()) {
        if (track.isNonnull()) {
          numPixelHits += track->hitPattern().numberOfValidPixelHits();
          nTracks++;
        }
      }
    }
    if (!(numPixelHits >= minPixelHits_)) {
      if (verbosity_) {
        edm::LogPrint("PFTauByHPSSelect") << " fails cut on sum of pixel hits.";
      }
      return 0.0;
    }
  }

  // Otherwise, we pass!
  if (verbosity_) {
    edm::LogPrint("PFTauByHPSSelect") << " passes all cuts.";
  }
  return 1.0;
}

fillDescriptions()

void PFRecoTauDiscriminationByHPSSelection::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 349 of file PFRecoTauDiscriminationByHPSSelection.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                       {
  // hpsSelectionDiscriminator
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("combinatoricRecoTaus"));
  desc.add<int>("verbosity", 0);
  desc.add<double>("minTauPt", 0.0);
  {
    edm::ParameterSetDescription psd0;
    psd0.add<std::string>("BooleanOperator", "and");
    desc.add<edm::ParameterSetDescription>("Prediscriminants", psd0);
  }

  {
    edm::ParameterSetDescription vpset_decayModes;
    vpset_decayModes.add<double>("minPi0Mass", -1.e3);
    vpset_decayModes.add<std::string>("maxMass");
    vpset_decayModes.add<double>("maxPi0Mass", 1.e9);
    vpset_decayModes.add<unsigned int>("nPiZeros");
    vpset_decayModes.add<double>("minMass");
    vpset_decayModes.add<unsigned int>("nChargedPFCandsMin", 0);
    vpset_decayModes.add<unsigned int>("nTracksMin", 0);
    vpset_decayModes.add<unsigned int>("nCharged");
    {
      edm::ParameterSetDescription psd0;
      psd0.add<bool>("phi");
      psd0.add<bool>("eta");
      psd0.add<bool>("mass");
      vpset_decayModes.add<edm::ParameterSetDescription>("applyBendCorrection", psd0);
    }
    vpset_decayModes.add<double>("assumeStripMass", -1.0);
    std::vector<edm::ParameterSet> vpset_default;
    {
      edm::ParameterSet pset;
      pset.addParameter<double>("minPi0Mass", -1.e3);
      pset.addParameter<double>("maxPi0Mass", 1.e9);
      pset.addParameter<unsigned int>("nChargedPFCandsMin", 0);
      pset.addParameter<unsigned int>("nTracksMin", 0);
      pset.addParameter<double>("assumeStripMass", -1.0);
      vpset_default.push_back(pset);
    }
    desc.addVPSet("decayModes", vpset_decayModes, vpset_default);
  }

  desc.add<double>("matchingCone", 0.5);
  desc.add<int>("minPixelHits", 1);
  desc.add<bool>("requireTauChargedHadronsToBeChargedPFCands", false);
  descriptions.add("hpsSelectionDiscriminator", desc);
}

Member Data Documentation

decayModeCuts_

DecayModeCutMap PFRecoTauDiscriminationByHPSSelection::decayModeCuts_

private

Definition at line 52 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), PFRecoTauDiscriminationByHPSSelection(), and ~PFRecoTauDiscriminationByHPSSelection().

matchingCone_

double PFRecoTauDiscriminationByHPSSelection::matchingCone_

private

Definition at line 53 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

minPixelHits_

int PFRecoTauDiscriminationByHPSSelection::minPixelHits_

private

Definition at line 58 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

minPt_

double PFRecoTauDiscriminationByHPSSelection::minPt_

private

Definition at line 54 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

requireTauChargedHadronsToBeChargedPFCands_

bool PFRecoTauDiscriminationByHPSSelection::requireTauChargedHadronsToBeChargedPFCands_

private

Definition at line 56 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

verbosity_

int PFRecoTauDiscriminationByHPSSelection::verbosity_

private

Definition at line 60 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().