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 >
virtual void	beginEvent (const edm::Event &, const edm::EventSetup &)
virtual double	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
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
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 >
typedef std::vector< TauType >	TauCollection
typedef edm::Ref< TauCollection >	TauRef
typedef edm::RefProd< TauCollection >	TauRefProd
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
std::string	moduleLabel_
double	prediscriminantFailValue_
edm::EDGetTokenT< TauCollection >	Tau_token
size_t	tauIndex_
edm::InputTag	TauProducer_

Detailed Description

Definition at line 23 of file PFRecoTauDiscriminationByHPSSelection.cc.

Member Typedef Documentation

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

private

Definition at line 55 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 54 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 53 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

private

Definition at line 33 of file PFRecoTauDiscriminationByHPSSelection.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 68 of file PFRecoTauDiscriminationByHPSSelection.cc.

References PFRecoTauDiscriminationByHPSSelection_cfi::applyBendCorrection, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_eta_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_phi_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, egammaForCoreTracking_cff::cuts, boostedTaus_cff::decayMode, decayModeCuts_, tauJetCorrFactors_cfi::decayModes, edm::ParameterSet::getParameter(), matchingCone_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::maxPi0Mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minMass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::minPi0Mass_, minPixelHits_, minPt_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nChargedPFCandsMin_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nTracksMin_, 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 ( )

override

Definition at line 106 of file PFRecoTauDiscriminationByHPSSelection.cc.

References decayModeCuts_, edm::Ref< C, T, F >::get(), getTrack(), reco::PFCandidate::gsfTrackRef(), pat::PackedCandidate::hasTrackDetails(), edm::Ref< C, T, F >::isNonnull(), pat::PackedCandidate::pseudoTrack(), and reco::PFCandidate::trackRef().

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

Member Function Documentation

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

override

Definition at line 132 of file PFRecoTauDiscriminationByHPSSelection.cc.

References funct::abs(), PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_eta_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_phi_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, muons2muons_cfi::chargedHadron, decayModeCuts_, reco::deltaPhi(), boostedElectronIsolation_cff::deltaR, particleFlow_cfi::dEta, particleFlow_cfi::dPhi, getTrack(), reco::TrackBase::hitPattern(), 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_, nTracks(), PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nTracksMin_, reco::HitPattern::numberOfValidPixelHits(), requireTauChargedHadronsToBeChargedPFCands_, AlCaHLTBitMon_QueryRunRegistry::string, HiIsolationCommonParameters_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;
    for (const auto& chargedHadrCand : tau->signalChargedHadrCands()) {
      const reco::Track* track = getTrack(*chargedHadrCand);
      if (track != nullptr) {
    numPixelHits += track->hitPattern().numberOfValidPixelHits();
      }
    }
    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;
}

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

static

Definition at line 343 of file PFRecoTauDiscriminationByHPSSelection.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, 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

DecayModeCutMap PFRecoTauDiscriminationByHPSSelection::decayModeCuts_

private

Definition at line 57 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

double PFRecoTauDiscriminationByHPSSelection::matchingCone_

private

Definition at line 58 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

int PFRecoTauDiscriminationByHPSSelection::minPixelHits_

private

Definition at line 63 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

double PFRecoTauDiscriminationByHPSSelection::minPt_

private

Definition at line 59 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

bool PFRecoTauDiscriminationByHPSSelection::requireTauChargedHadronsToBeChargedPFCands_

private

Definition at line 61 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().

int PFRecoTauDiscriminationByHPSSelection::verbosity_

private

Definition at line 65 of file PFRecoTauDiscriminationByHPSSelection.cc.

Referenced by discriminate(), and PFRecoTauDiscriminationByHPSSelection().