CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Static Public Member Functions | Private Types | Private Attributes
PFRecoTauDiscriminationByHPSSelection Class Reference
Inheritance diagram for PFRecoTauDiscriminationByHPSSelection:
TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType > edm::stream::EDProducer<>

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 ()
 
 TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)
 
 ~TauDiscriminationProducerBase () override
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

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<>
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, 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.

64  : PFTauDiscriminationProducerBase(pset) {
65  // Get the matchign cut
66  matchingCone_ = pset.getParameter<double>("matchingCone");
67  minPt_ = pset.getParameter<double>("minTauPt");
68  // Get the mass cuts for each decay mode
69  typedef std::vector<edm::ParameterSet> VPSet;
70  const VPSet& decayModes = pset.getParameter<VPSet>("decayModes");
71  for (auto const& decayMode : decayModes) {
72  // The mass window(s)
73  DecayModeCuts cuts;
74  cuts.nTracksMin_ = decayMode.getParameter<unsigned>("nTracksMin");
75  cuts.nChargedPFCandsMin_ = decayMode.getParameter<unsigned>("nChargedPFCandsMin");
76  cuts.minMass_ = decayMode.getParameter<double>("minMass");
77  cuts.maxMass_ = new TauFunc(decayMode.getParameter<std::string>("maxMass"));
78  edm::ParameterSet applyBendCorrection = decayMode.getParameter<edm::ParameterSet>("applyBendCorrection");
79  cuts.applyBendCorrection_eta_ = applyBendCorrection.getParameter<bool>("eta");
80  cuts.applyBendCorrection_phi_ = applyBendCorrection.getParameter<bool>("phi");
81  cuts.applyBendCorrection_mass_ = applyBendCorrection.getParameter<bool>("mass");
82  cuts.minPi0Mass_ = decayMode.getParameter<double>("minPi0Mass");
83  cuts.maxPi0Mass_ = decayMode.getParameter<double>("maxPi0Mass");
84  cuts.assumeStripMass_ = decayMode.getParameter<double>("assumeStripMass");
85  decayModeCuts_.insert(std::make_pair(
86  // The decay mode as a key
87  std::make_pair(decayMode.getParameter<uint32_t>("nCharged"), decayMode.getParameter<uint32_t>("nPiZeros")),
88  cuts));
89  }
90  requireTauChargedHadronsToBeChargedPFCands_ = pset.getParameter<bool>("requireTauChargedHadronsToBeChargedPFCands");
91  minPixelHits_ = pset.getParameter<int>("minPixelHits");
92  verbosity_ = pset.getParameter<int>("verbosity");
93 }

References HLT_2018_cff::applyBendCorrection, L1TMuonDQMOffline_cfi::cuts, taus_cff::decayMode, decayModeCuts_, HLT_2018_cff::decayModes, matchingCone_, minPixelHits_, minPt_, muonDTDigis_cfi::pset, requireTauChargedHadronsToBeChargedPFCands_, AlCaHLTBitMon_QueryRunRegistry::string, verbosity_, and HistogramManager_cfi::VPSet().

◆ ~PFRecoTauDiscriminationByHPSSelection()

PFRecoTauDiscriminationByHPSSelection::~PFRecoTauDiscriminationByHPSSelection ( )
override

Definition at line 95 of file PFRecoTauDiscriminationByHPSSelection.cc.

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

References decayModeCuts_.

Member Function Documentation

◆ discriminate()

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

Definition at line 120 of file PFRecoTauDiscriminationByHPSSelection.cc.

120  {
121  if (verbosity_) {
122  edm::LogPrint("PFTauByHPSSelect") << "<PFRecoTauDiscriminationByHPSSelection::discriminate>:";
123  edm::LogPrint("PFTauByHPSSelect") << " nCharged = " << tau->signalTauChargedHadronCandidates().size();
124  edm::LogPrint("PFTauByHPSSelect") << " nPiZeros = " << tau->signalPiZeroCandidates().size();
125  }
126 
127  // Check if we pass the min pt
128  if (tau->pt() < minPt_) {
129  if (verbosity_) {
130  edm::LogPrint("PFTauByHPSSelect") << " fails minPt cut.";
131  }
132  return 0.0;
133  }
134 
135  // See if we select this decay mode
136  DecayModeCutMap::const_iterator massWindowIter = decayModeCuts_.find(
137  std::make_pair(tau->signalTauChargedHadronCandidates().size(), tau->signalPiZeroCandidates().size()));
138  // Check if decay mode is supported
139  if (massWindowIter == decayModeCuts_.end()) {
140  if (verbosity_) {
141  edm::LogPrint("PFTauByHPSSelect") << " fails mass-window definition requirement.";
142  }
143  return 0.0;
144  }
145  const DecayModeCuts& massWindow = massWindowIter->second;
146 
147  if (massWindow.nTracksMin_ > 0) {
148  unsigned int nTracks = 0;
149  const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
150  for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
151  chargedHadron != chargedHadrons.end();
152  ++chargedHadron) {
153  if (chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate) ||
154  chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kTrack)) {
155  ++nTracks;
156  }
157  }
158  if (verbosity_) {
159  edm::LogPrint("PFTauByHPSSelect") << "nTracks = " << nTracks << " (min = " << massWindow.nTracksMin_ << ")";
160  }
161  if (nTracks < massWindow.nTracksMin_) {
162  if (verbosity_) {
163  edm::LogPrint("PFTauByHPSSelect") << " fails nTracks requirement for mass-window.";
164  }
165  return 0.0;
166  }
167  }
168  if (massWindow.nChargedPFCandsMin_ > 0) {
169  unsigned int nChargedPFCands = 0;
170  const std::vector<reco::PFRecoTauChargedHadron>& chargedHadrons = tau->signalTauChargedHadronCandidates();
171  for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator chargedHadron = chargedHadrons.begin();
172  chargedHadron != chargedHadrons.end();
173  ++chargedHadron) {
174  if (chargedHadron->algoIs(reco::PFRecoTauChargedHadron::kChargedPFCandidate)) {
175  ++nChargedPFCands;
176  }
177  }
178  if (verbosity_) {
179  edm::LogPrint("PFTauByHPSSelect") << "nChargedPFCands = " << nChargedPFCands
180  << " (min = " << massWindow.nChargedPFCandsMin_ << ")";
181  }
182  if (nChargedPFCands < massWindow.nChargedPFCandsMin_) {
183  if (verbosity_) {
184  edm::LogPrint("PFTauByHPSSelect") << " fails nChargedPFCands requirement for mass-window.";
185  }
186  return 0.0;
187  }
188  }
189 
190  math::XYZTLorentzVector tauP4 = tau->p4();
191  if (verbosity_) {
192  edm::LogPrint("PFTauByHPSSelect") << "tau: Pt = " << tauP4.pt() << ", eta = " << tauP4.eta()
193  << ", phi = " << tauP4.phi() << ", mass = " << tauP4.mass();
194  }
195  // Find the total pizero p4
196  reco::Candidate::LorentzVector stripsP4;
197  for (auto const& cand : tau->signalPiZeroCandidates()) {
198  const math::XYZTLorentzVector& candP4 = cand.p4();
199  stripsP4 += candP4;
200  }
201 
202  // Apply strip mass assumption corrections
203  if (massWindow.assumeStripMass_ >= 0) {
204  for (auto const& cand : tau->signalPiZeroCandidates()) {
205  const math::XYZTLorentzVector& uncorrected = cand.p4();
206  math::XYZTLorentzVector corrected = applyMassConstraint(uncorrected, massWindow.assumeStripMass_);
207  math::XYZTLorentzVector correction = corrected - uncorrected;
208  tauP4 += correction;
209  stripsP4 += correction;
210  }
211  }
212  if (verbosity_) {
213  edm::LogPrint("PFTauByHPSSelect") << "strips: Pt = " << stripsP4.pt() << ", eta = " << stripsP4.eta()
214  << ", phi = " << stripsP4.phi() << ", mass = " << stripsP4.mass();
215  }
216 
217  // Check if tau fails mass cut
218  double maxMass_value = (*massWindow.maxMass_)(*tau);
219  double bendCorrection_mass = (massWindow.applyBendCorrection_mass_) ? tau->bendCorrMass() : 0.;
220  if (!((tauP4.M() - bendCorrection_mass) < maxMass_value && (tauP4.M() + bendCorrection_mass) > massWindow.minMass_)) {
221  if (verbosity_) {
222  edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut.";
223  }
224  return 0.0;
225  }
226  // CV: require that mass of charged tau decay products is always within specified mass window,
227  // irrespective of bendCorrection_mass
228  reco::Candidate::LorentzVector tauP4_charged;
229  const std::vector<reco::PFRecoTauChargedHadron>& signalChargedHadrons = tau->signalTauChargedHadronCandidates();
230  for (std::vector<reco::PFRecoTauChargedHadron>::const_iterator signalChargedHadron = signalChargedHadrons.begin();
231  signalChargedHadron != signalChargedHadrons.end();
232  ++signalChargedHadron) {
233  tauP4_charged += signalChargedHadron->p4();
234  }
235  if (!(tauP4_charged.mass() < maxMass_value)) {
236  if (verbosity_) {
237  edm::LogPrint("PFTauByHPSSelect") << " fails tau mass-window cut.";
238  }
239  return 0.0;
240  }
241 
242  // Check if it fails the pi0 IM cut
243  if (stripsP4.M() > massWindow.maxPi0Mass_ || stripsP4.M() < massWindow.minPi0Mass_) {
244  if (verbosity_) {
245  edm::LogPrint("PFTauByHPSSelect") << " fails strip mass-window cut.";
246  }
247  return 0.0;
248  }
249 
250  // Check if tau passes matching cone cut
251  //edm::LogPrint("PFTauByHPSSelect") << "dR(tau, jet) = " << deltaR(tauP4, tau->jetRef()->p4()) ;
252  if (deltaR(tauP4, tau->jetRef()->p4()) > matchingCone_) {
253  if (verbosity_) {
254  edm::LogPrint("PFTauByHPSSelect") << " fails matching-cone cut.";
255  }
256  return 0.0;
257  }
258 
259  // Check if tau passes cone cut
260  double cone_size = tau->signalConeSize();
261  // Check if any charged objects fail the signal cone cut
262  for (auto const& cand : tau->signalTauChargedHadronCandidates()) {
263  if (verbosity_) {
264  edm::LogPrint("PFTauByHPSSelect") << "dR(tau, signalPFChargedHadr) = " << deltaR(cand.p4(), tauP4);
265  }
266  if (deltaR(cand.p4(), tauP4) > cone_size) {
267  if (verbosity_) {
268  edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for charged hadron(s).";
269  }
270  return 0.0;
271  }
272  }
273  // Now check the pizeros
274  for (auto const& cand : tau->signalPiZeroCandidates()) {
275  double bendCorrection_eta = (massWindow.applyBendCorrection_eta_) ? cand.bendCorrEta() : 0.;
276  double dEta = std::max(0., fabs(cand.eta() - tauP4.eta()) - bendCorrection_eta);
277  double bendCorrection_phi = (massWindow.applyBendCorrection_phi_) ? cand.bendCorrPhi() : 0.;
278  double dPhi = std::max(0., std::abs(reco::deltaPhi(cand.phi(), tauP4.phi())) - bendCorrection_phi);
279  double dR2 = dEta * dEta + dPhi * dPhi;
280  if (verbosity_) {
281  edm::LogPrint("PFTauByHPSSelect") << "dR2(tau, signalPiZero) = " << dR2;
282  }
283  if (dR2 > cone_size * cone_size) {
284  if (verbosity_) {
285  edm::LogPrint("PFTauByHPSSelect") << " fails signal-cone cut for strip(s).";
286  }
287  return 0.0;
288  }
289  }
290 
291  if (requireTauChargedHadronsToBeChargedPFCands_) {
292  for (auto const& cand : tau->signalTauChargedHadronCandidates()) {
293  if (verbosity_) {
294  std::string algo_string;
295  if (cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate)
296  algo_string = "ChargedPFCandidate";
297  else if (cand.algo() == reco::PFRecoTauChargedHadron::kTrack)
298  algo_string = "Track";
299  else if (cand.algo() == reco::PFRecoTauChargedHadron::kPFNeutralHadron)
300  algo_string = "PFNeutralHadron";
301  else
302  algo_string = "Undefined";
303  edm::LogPrint("PFTauByHPSSelect") << "algo(signalPFChargedHadr) = " << algo_string;
304  }
305  if (!(cand.algo() == reco::PFRecoTauChargedHadron::kChargedPFCandidate)) {
306  if (verbosity_) {
307  edm::LogPrint("PFTauByHPSSelect") << " fails cut on PFRecoTauChargedHadron algo.";
308  }
309  return 0.0;
310  }
311  }
312  }
313 
314  if (minPixelHits_ > 0) {
315  int numPixelHits = 0;
316  for (const auto& chargedHadrCand : tau->signalChargedHadrCands()) {
317  const reco::Track* track = getTrack(*chargedHadrCand);
318  if (track != nullptr) {
319  numPixelHits += track->hitPattern().numberOfValidPixelHits();
320  }
321  }
322  if (!(numPixelHits >= minPixelHits_)) {
323  if (verbosity_) {
324  edm::LogPrint("PFTauByHPSSelect") << " fails cut on sum of pixel hits.";
325  }
326  return 0.0;
327  }
328  }
329 
330  // Otherwise, we pass!
331  if (verbosity_) {
332  edm::LogPrint("PFTauByHPSSelect") << " passes all cuts.";
333  }
334  return 1.0;
335 }

References funct::abs(), PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_eta_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_mass_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::applyBendCorrection_phi_, PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::assumeStripMass_, muons2muons_cfi::chargedHadron, pfMETCorrectionType0_cfi::correction, decayModeCuts_, reco::deltaPhi(), PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2018_cff::dEta, HLT_2018_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_, nTracks(), PFRecoTauDiscriminationByHPSSelection::DecayModeCuts::nTracksMin_, requireTauChargedHadronsToBeChargedPFCands_, AlCaHLTBitMon_QueryRunRegistry::string, metsig::tau, HLT_2018_cff::track, and verbosity_.

◆ fillDescriptions()

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

Definition at line 337 of file PFRecoTauDiscriminationByHPSSelection.cc.

337  {
338  // hpsSelectionDiscriminator
339  edm::ParameterSetDescription desc;
340  desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("combinatoricRecoTaus"));
341  desc.add<int>("verbosity", 0);
342  desc.add<double>("minTauPt", 0.0);
343  {
344  edm::ParameterSetDescription psd0;
345  psd0.add<std::string>("BooleanOperator", "and");
346  desc.add<edm::ParameterSetDescription>("Prediscriminants", psd0);
347  }
348 
349  {
350  edm::ParameterSetDescription vpset_decayModes;
351  vpset_decayModes.add<double>("minPi0Mass", -1.e3);
352  vpset_decayModes.add<std::string>("maxMass");
353  vpset_decayModes.add<double>("maxPi0Mass", 1.e9);
354  vpset_decayModes.add<unsigned int>("nPiZeros");
355  vpset_decayModes.add<double>("minMass");
356  vpset_decayModes.add<unsigned int>("nChargedPFCandsMin", 0);
357  vpset_decayModes.add<unsigned int>("nTracksMin", 0);
358  vpset_decayModes.add<unsigned int>("nCharged");
359  {
360  edm::ParameterSetDescription psd0;
361  psd0.add<bool>("phi");
362  psd0.add<bool>("eta");
363  psd0.add<bool>("mass");
364  vpset_decayModes.add<edm::ParameterSetDescription>("applyBendCorrection", psd0);
365  }
366  vpset_decayModes.add<double>("assumeStripMass", -1.0);
367  std::vector<edm::ParameterSet> vpset_default;
368  {
369  edm::ParameterSet pset;
370  pset.addParameter<double>("minPi0Mass", -1.e3);
371  pset.addParameter<double>("maxPi0Mass", 1.e9);
372  pset.addParameter<unsigned int>("nChargedPFCandsMin", 0);
373  pset.addParameter<unsigned int>("nTracksMin", 0);
374  pset.addParameter<double>("assumeStripMass", -1.0);
375  vpset_default.push_back(pset);
376  }
377  desc.addVPSet("decayModes", vpset_decayModes, vpset_default);
378  }
379 
380  desc.add<double>("matchingCone", 0.5);
381  desc.add<int>("minPixelHits", 1);
382  desc.add<bool>("requireTauChargedHadronsToBeChargedPFCands", false);
383  descriptions.add("hpsSelectionDiscriminator", desc);
384 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addVPSet(), HLT_2018_cff::InputTag, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

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().

nTracks
const unsigned int nTracks(const reco::Vertex &sv)
Definition: TemplatedVertexArbitrator.h:44
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
PFRecoTauDiscriminationByHPSSelection::minPixelHits_
int minPixelHits_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:58
metsig::tau
Definition: SignAlgoResolutions.h:49
muons2muons_cfi.chargedHadron
chargedHadron
Definition: muons2muons_cfi.py:26
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
PFRecoTauDiscriminationByHPSSelection::minPt_
double minPt_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:54
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
PFTauDiscriminationProducerBase
TauDiscriminationProducerBase< reco::PFTau, reco::PFTauDiscriminator > PFTauDiscriminationProducerBase
Definition: TauDiscriminationProducerBase.h:124
HLT_2018_cff.dEta
dEta
Definition: HLT_2018_cff.py:12289
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
HLT_2018_cff.dPhi
dPhi
Definition: HLT_2018_cff.py:12290
reco::Track
Definition: Track.h:27
HLT_2018_cff.decayModes
decayModes
Definition: HLT_2018_cff.py:31796
taus_cff.decayMode
decayMode
Definition: taus_cff.py:60
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_2018_cff.applyBendCorrection
applyBendCorrection
Definition: HLT_2018_cff.py:31912
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
edm::ParameterSet
Definition: ParameterSet.h:36
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
pfMETCorrectionType0_cfi.correction
correction
Definition: pfMETCorrectionType0_cfi.py:39
reco::PFRecoTauChargedHadron::kChargedPFCandidate
Definition: PFRecoTauChargedHadron.h:30
cand
Definition: decayParser.h:34
edm::LogPrint
Definition: MessageLogger.h:342
PFRecoTauDiscriminationByHPSSelection::decayModeCuts_
DecayModeCutMap decayModeCuts_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:52
PFRecoTauDiscriminationByHPSSelection::matchingCone_
double matchingCone_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:53
getTrack
static const TrackGhostTrackState * getTrack(const BasicGhostTrackState *basic)
Definition: GhostTrackState.cc:49
HistogramManager_cfi.VPSet
def VPSet(*args)
Definition: HistogramManager_cfi.py:401
reco::PFRecoTauChargedHadron::kPFNeutralHadron
Definition: PFRecoTauChargedHadron.h:32
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
PFRecoTauDiscriminationByHPSSelection::TauFunc
StringObjectFunction< reco::PFTau > TauFunc
Definition: PFRecoTauDiscriminationByHPSSelection.cc:31
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
PFRecoTauDiscriminationByHPSSelection::verbosity_
int verbosity_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:60
L1TMuonDQMOffline_cfi.cuts
cuts
Definition: L1TMuonDQMOffline_cfi.py:41
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:36
edm::InputTag
Definition: InputTag.h:15
PFRecoTauDiscriminationByHPSSelection::requireTauChargedHadronsToBeChargedPFCands_
bool requireTauChargedHadronsToBeChargedPFCands_
Definition: PFRecoTauDiscriminationByHPSSelection.cc:56
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
reco::PFRecoTauChargedHadron::kTrack
Definition: PFRecoTauChargedHadron.h:31
Generated for CMSSW Reference Manual by doxygen 1.8.16