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 hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () 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_FULL_cff::applyBendCorrection, L1TMuonDQMOffline_cfi::cuts, taus_cff::decayMode, decayModeCuts_, HLT_FULL_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_FULL_cff::dEta, HLT_FULL_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_FULL_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(), submitPVResolutionJobs::desc, HLT_FULL_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().

edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11779
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::LogPrint
Log< level::Warning, true > LogPrint
Definition: MessageLogger.h:130
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89353
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
PFTauDiscriminationProducerBase
TauDiscriminationProducerBase< reco::PFTau, reco::PFTauDiscriminator > PFTauDiscriminationProducerBase
Definition: TauDiscriminationProducerBase.h:124
HLT_FULL_cff.dPhi
dPhi
Definition: HLT_FULL_cff.py:13768
BeamSpotPI::nTracks
Definition: BeamSpotPayloadInspectorHelper.h:41
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
reco::Track
Definition: Track.h:27
taus_cff.decayMode
decayMode
Definition: taus_cff.py:58
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::ParameterSet
Definition: ParameterSet.h:47
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:32
HLT_FULL_cff.applyBendCorrection
applyBendCorrection
Definition: HLT_FULL_cff.py:33430
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
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
HistogramManager_cfi.VPSet
def VPSet(*args)
Definition: HistogramManager_cfi.py:401
reco::PFRecoTauChargedHadron::kPFNeutralHadron
Definition: PFRecoTauChargedHadron.h:32
HLT_FULL_cff.dEta
dEta
Definition: HLT_FULL_cff.py:13767
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
HLT_FULL_cff.decayModes
decayModes
Definition: HLT_FULL_cff.py:33314
PFRecoTauDiscriminationByHPSSelection::TauFunc
StringObjectFunction< reco::PFTau > TauFunc
Definition: PFRecoTauDiscriminationByHPSSelection.cc:31
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