CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
PFRecoTauDiscriminationByIsolation.cc
Go to the documentation of this file.
1 #include <functional>
12 
13 #include "TMath.h"
14 #include "TFormula.h"
15 
16 /* class PFRecoTauDiscriminationByIsolation
17  * created : Jul 23 2007,
18  * revised : Thu Aug 13 14:44:40 PDT 2009
19  * contributors : Ludovic Houchu (IPHC, Strasbourg),
20  * Christian Veelken (UC Davis),
21  * Evan K. Friis (UC Davis)
22  * Michalis Bachtis (UW Madison)
23  */
24 
25 using namespace reco;
26 using namespace std;
27 
29 public:
32  moduleLabel_(pset.getParameter<std::string>("@module_label")),
33  qualityCutsPSet_(pset.getParameter<edm::ParameterSet>("qualityCuts")) {
34  includeTracks_ = pset.getParameter<bool>("ApplyDiscriminationByTrackerIsolation");
35  includeGammas_ = pset.getParameter<bool>("ApplyDiscriminationByECALIsolation");
36 
37  calculateWeights_ = pset.getParameter<bool>("ApplyDiscriminationByWeightedECALIsolation");
38 
39  enableHGCalWorkaround_ = pset.getParameter<bool>("enableHGCalWorkaround");
40 
41  // RIC: multiply neutral isolation by a flat factor.
42  // Useful, for instance, to combine charged and neutral isolations
43  // with different relative weights
44  weightGammas_ = pset.getParameter<double>("WeightECALIsolation");
45 
46  // RIC: allow to relax the isolation completely beyond a given tau pt
47  minPtForNoIso_ = pset.getParameter<double>("minTauPtForNoIso");
48 
49  applyOccupancyCut_ = pset.getParameter<bool>("applyOccupancyCut");
50  maximumOccupancy_ = pset.getParameter<uint32_t>("maximumOccupancy");
51 
52  applySumPtCut_ = pset.getParameter<bool>("applySumPtCut");
53  maximumSumPt_ = pset.getParameter<double>("maximumSumPtCut");
54 
55  applyRelativeSumPtCut_ = pset.getParameter<bool>("applyRelativeSumPtCut");
56  maximumRelativeSumPt_ = pset.getParameter<double>("relativeSumPtCut");
57  offsetRelativeSumPt_ = pset.getParameter<double>("relativeSumPtOffset");
58 
59  storeRawOccupancy_ = pset.getParameter<bool>("storeRawOccupancy");
60  storeRawSumPt_ = pset.getParameter<bool>("storeRawSumPt");
61  storeRawPUsumPt_ = pset.getParameter<bool>("storeRawPUsumPt");
62  storeRawFootprintCorrection_ = pset.getParameter<bool>("storeRawFootprintCorrection");
63  storeRawPhotonSumPt_outsideSignalCone_ = pset.getParameter<bool>("storeRawPhotonSumPt_outsideSignalCone");
64 
65  // Sanity check on requested options. We can't apply cuts and store the
66  // raw output at the same time
67  if (applySumPtCut_ || applyOccupancyCut_ || applyRelativeSumPtCut_) {
68  if (storeRawSumPt_ || storeRawOccupancy_ || storeRawPUsumPt_) {
69  throw cms::Exception("BadIsoConfig") << "A 'store raw' and a 'apply cut' option have been set to true "
70  << "simultaneously. These options are mutually exclusive.";
71  }
72  }
73 
74  // sanity check2 - can't use weighted and unweighted iso at the same time
75  if (includeGammas_ && calculateWeights_) {
76  throw cms::Exception("BasIsoConfig")
77  << "Both 'ApplyDiscriminationByECALIsolation' and 'ApplyDiscriminationByWeightedECALIsolation' "
78  << "have been set to true. These options are mutually exclusive.";
79  }
80 
81  // Can only store one type
82  int numStoreOptions = 0;
83  if (storeRawSumPt_)
84  ++numStoreOptions;
85  if (storeRawOccupancy_)
86  ++numStoreOptions;
87  if (storeRawPUsumPt_)
88  ++numStoreOptions;
89  if (storeRawFootprintCorrection_)
90  ++numStoreOptions;
91  if (storeRawPhotonSumPt_outsideSignalCone_)
92  ++numStoreOptions;
93  if (numStoreOptions > 1) {
94  throw cms::Exception("BadIsoConfig") << "Multiple 'store sum pt' and/or 'store occupancy' options are set."
95  << " These options are mutually exclusive.";
96  }
97 
98  customIsoCone_ = pset.getParameter<double>("customOuterCone");
99 
100  applyPhotonPtSumOutsideSignalConeCut_ = pset.getParameter<bool>("applyPhotonPtSumOutsideSignalConeCut");
101  if (applyPhotonPtSumOutsideSignalConeCut_) {
102  maxAbsPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxAbsPhotonSumPt_outsideSignalCone");
103  maxRelPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxRelPhotonSumPt_outsideSignalCone");
104  }
105 
106  applyFootprintCorrection_ = pset.getParameter<bool>("applyFootprintCorrection");
107  if (applyFootprintCorrection_ || storeRawFootprintCorrection_) {
108  edm::VParameterSet cfgFootprintCorrections = pset.getParameter<edm::VParameterSet>("footprintCorrections");
109  for (edm::VParameterSet::const_iterator cfgFootprintCorrection = cfgFootprintCorrections.begin();
110  cfgFootprintCorrection != cfgFootprintCorrections.end();
111  ++cfgFootprintCorrection) {
112  std::string selection = cfgFootprintCorrection->getParameter<std::string>("selection");
113  std::string offset = cfgFootprintCorrection->getParameter<std::string>("offset");
114  std::unique_ptr<FootprintCorrection> footprintCorrection(new FootprintCorrection(selection, offset));
115  footprintCorrections_.push_back(std::move(footprintCorrection));
116  }
117  }
118 
119  // Get the quality cuts specific to the isolation region
120  edm::ParameterSet isolationQCuts = qualityCutsPSet_.getParameterSet("isolationQualityCuts");
121 
122  qcuts_.reset(new tau::RecoTauQualityCuts(isolationQCuts));
123 
124  vertexAssociator_.reset(new tau::RecoTauVertexAssociator(qualityCutsPSet_, consumesCollector()));
125 
126  applyDeltaBeta_ = pset.getParameter<bool>("applyDeltaBetaCorrection");
127 
128  if (applyDeltaBeta_ || calculateWeights_) {
129  // Factorize the isolation QCuts into those that are used to
130  // select PU and those that are not.
131  std::pair<edm::ParameterSet, edm::ParameterSet> puFactorizedIsoQCuts =
132  reco::tau::factorizePUQCuts(isolationQCuts);
133 
134  // Determine the pt threshold for the PU tracks
135  // First check if the user specifies explicitly the cut.
136  // For that the user has to provide a >= 0 value for the PtCutOverride.
137  bool deltaBetaPUTrackPtCutOverride = pset.getParameter<bool>("deltaBetaPUTrackPtCutOverride");
139  double deltaBetaPUTrackPtCutOverride_val = pset.getParameter<double>("deltaBetaPUTrackPtCutOverride_val");
140  puFactorizedIsoQCuts.second.addParameter<double>("minTrackPt", deltaBetaPUTrackPtCutOverride_val);
141  } else {
142  // Secondly take it from the minGammaEt
143  puFactorizedIsoQCuts.second.addParameter<double>("minTrackPt",
144  isolationQCuts.getParameter<double>("minGammaEt"));
145  }
146 
147  pileupQcutsPUTrackSelection_.reset(new tau::RecoTauQualityCuts(puFactorizedIsoQCuts.first));
148 
149  pileupQcutsGeneralQCuts_.reset(new tau::RecoTauQualityCuts(puFactorizedIsoQCuts.second));
150 
151  pfCandSrc_ = pset.getParameter<edm::InputTag>("particleFlowSrc");
152  pfCand_token = consumes<edm::View<reco::Candidate> >(pfCandSrc_);
153  vertexSrc_ = pset.getParameter<edm::InputTag>("vertexSrc");
154  vertex_token = consumes<reco::VertexCollection>(vertexSrc_);
155  deltaBetaCollectionCone_ = pset.getParameter<double>("isoConeSizeForDeltaBeta");
156  std::string deltaBetaFactorFormula = pset.getParameter<string>("deltaBetaFactor");
157  deltaBetaFormula_.reset(new TFormula("DB_corr", deltaBetaFactorFormula.c_str()));
158  }
159 
160  applyRhoCorrection_ = pset.getParameter<bool>("applyRhoCorrection");
161  if (applyRhoCorrection_) {
162  rhoProducer_ = pset.getParameter<edm::InputTag>("rhoProducer");
163  rho_token = consumes<double>(rhoProducer_);
164  rhoConeSize_ = pset.getParameter<double>("rhoConeSize");
165  rhoUEOffsetCorrection_ = pset.getParameter<double>("rhoUEOffsetCorrection");
166  }
167  useAllPFCands_ = pset.getParameter<bool>("UseAllPFCandsForWeights");
168 
169  verbosity_ = pset.getParameter<int>("verbosity");
170  }
171 
173 
174  void beginEvent(const edm::Event& evt, const edm::EventSetup& evtSetup) override;
175  double discriminate(const PFTauRef& pfTau) const override;
176 
177  inline double weightedSum(const std::vector<CandidatePtr>& inColl_, double eta, double phi) const {
178  double out = 1.0;
179  for (auto const& inObj_ : inColl_) {
180  double sum = (inObj_->pt() * inObj_->pt()) / (deltaR2(eta, phi, inObj_->eta(), inObj_->phi()));
181  if (sum > 1.0)
182  out *= sum;
183  }
184  return out;
185  }
186 
187  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
188 
189 private:
191 
193  std::unique_ptr<tau::RecoTauQualityCuts> qcuts_;
194 
195  // Inverted QCut which selects tracks with bad DZ/trackWeight
196  std::unique_ptr<tau::RecoTauQualityCuts> pileupQcutsPUTrackSelection_;
197  std::unique_ptr<tau::RecoTauQualityCuts> pileupQcutsGeneralQCuts_;
198 
199  std::unique_ptr<tau::RecoTauVertexAssociator> vertexAssociator_;
200 
214  // RIC:
216 
220 
224  : selection_(selection), offset_(offset) {}
228  };
229  std::vector<std::unique_ptr<FootprintCorrection> > footprintCorrections_;
230 
231  // Options to store the raw value in the discriminator instead of boolean pass/fail flag
237 
238  /* **********************************************************************
239  **** Pileup Subtraction Parameters ***********************************
240  **********************************************************************/
241 
242  // Delta Beta correction
246  // Keep track of how many vertices are in the event
249  std::vector<reco::CandidatePtr> chargedPFCandidatesInEvent_;
250  // Size of cone used to collect PU tracks
252  std::unique_ptr<TFormula> deltaBetaFormula_;
254 
255  // Rho correction
260  double rhoConeSize_;
264 
265  // Flag to enable/disable debug output
267 };
268 
270  // NB: The use of the PV in this context is necessitated by its use in
271  // applying quality cuts to the different objects in the isolation cone
272  // The vertex associator contains the logic to select the appropriate vertex
273  // We need to pass it the event so it can load the vertices.
274  vertexAssociator_->setEvent(event);
275 
276  // If we are applying the delta beta correction, we need to get the PF
277  // candidates from the event so we can find the PU tracks.
278  if (applyDeltaBeta_ || calculateWeights_) {
279  // Collect all the PF pile up tracks
281  event.getByToken(pfCand_token, pfCandidates);
282  chargedPFCandidatesInEvent_.clear();
283  chargedPFCandidatesInEvent_.reserve(pfCandidates->size());
284  size_t numPFCandidates = pfCandidates->size();
285  for (size_t i = 0; i < numPFCandidates; ++i) {
286  reco::CandidatePtr pfCandidate(pfCandidates, i);
287  if (pfCandidate->charge() != 0) {
288  chargedPFCandidatesInEvent_.push_back(pfCandidate);
289  }
290  }
291  // Count all the vertices in the event, to parameterize the DB
292  // correction factor
294  event.getByToken(vertex_token, vertices);
295  size_t nVtxThisEvent = vertices->size();
296  deltaBetaFactorThisEvent_ = deltaBetaFormula_->Eval(nVtxThisEvent);
297  }
298 
299  if (applyRhoCorrection_) {
300  edm::Handle<double> rhoHandle_;
301  event.getByToken(rho_token, rhoHandle_);
302  rhoThisEvent_ = (*rhoHandle_ - rhoUEOffsetCorrection_) * (3.14159) * rhoConeSize_ * rhoConeSize_;
303  }
304 }
305 
307  LogDebug("discriminate") << " tau: Pt = " << pfTau->pt() << ", eta = " << pfTau->eta() << ", phi = " << pfTau->phi();
308  LogDebug("discriminate") << *pfTau;
309 
310  // collect the objects we are working with (ie tracks, tracks+gammas, etc)
311  std::vector<CandidatePtr> isoCharged_;
312  std::vector<CandidatePtr> isoNeutral_;
313  std::vector<CandidatePtr> isoPU_;
314  CandidateCollection isoNeutralWeight_;
315  std::vector<CandidatePtr> chPV_;
316  isoCharged_.reserve(pfTau->isolationChargedHadrCands().size());
317  isoNeutral_.reserve(pfTau->isolationGammaCands().size());
318  isoPU_.reserve(std::min(100UL, chargedPFCandidatesInEvent_.size()));
319  isoNeutralWeight_.reserve(pfTau->isolationGammaCands().size());
320 
321  chPV_.reserve(std::min(50UL, chargedPFCandidatesInEvent_.size()));
322 
323  // Get the primary vertex associated to this tau
324  reco::VertexRef pv = vertexAssociator_->associatedVertex(*pfTau);
325  // Let the quality cuts know which the vertex to use when applying selections
326  // on dz, etc.
327  if (verbosity_) {
328  if (pv.isNonnull()) {
329  LogTrace("discriminate") << "pv: x = " << pv->position().x() << ", y = " << pv->position().y()
330  << ", z = " << pv->position().z();
331  } else {
332  LogTrace("discriminate") << "pv: N/A";
333  }
334  if (pfTau->leadChargedHadrCand().isNonnull()) {
335  LogTrace("discriminate") << "leadPFChargedHadron:"
336  << " Pt = " << pfTau->leadChargedHadrCand()->pt() << ","
337  << " eta = " << pfTau->leadChargedHadrCand()->eta() << ","
338  << " phi = " << pfTau->leadChargedHadrCand()->phi();
339  } else {
340  LogTrace("discriminate") << "leadPFChargedHadron: N/A";
341  }
342  }
343 
344  // CV: isolation is not well defined in case primary vertex or leading charged hadron do not exist
345  if (!(pv.isNonnull() && pfTau->leadChargedHadrCand().isNonnull()))
346  return 0.;
347 
348  qcuts_->setPV(pv);
349  qcuts_->setLeadTrack(*pfTau->leadChargedHadrCand());
350 
351  if (applyDeltaBeta_ || calculateWeights_) {
352  pileupQcutsGeneralQCuts_->setPV(pv);
353  pileupQcutsGeneralQCuts_->setLeadTrack(*pfTau->leadChargedHadrCand());
354  pileupQcutsPUTrackSelection_->setPV(pv);
355  pileupQcutsPUTrackSelection_->setLeadTrack(*pfTau->leadChargedHadrCand());
356  }
357 
358  // Load the tracks if they are being used.
359  if (includeTracks_) {
360  for (auto const& cand : pfTau->isolationChargedHadrCands()) {
361  if (qcuts_->filterCandRef(cand)) {
362  LogTrace("discriminate") << "adding charged iso cand with pt " << cand->pt();
363  isoCharged_.push_back(cand);
364  }
365  }
366  }
367  if (includeGammas_ || calculateWeights_) {
368  for (auto const& cand : pfTau->isolationGammaCands()) {
369  if (qcuts_->filterCandRef(cand)) {
370  LogTrace("discriminate") << "adding neutral iso cand with pt " << cand->pt();
371  isoNeutral_.push_back(cand);
372  }
373  }
374  }
375 
378 
379  // If desired, get PU tracks.
380  if (applyDeltaBeta_ || calculateWeights_) {
381  // First select by inverted the DZ/track weight cuts. True = invert
382  if (verbosity_) {
383  std::cout << "Initial PFCands: " << chargedPFCandidatesInEvent_.size() << std::endl;
384  }
385 
386  std::vector<CandidatePtr> allPU = pileupQcutsPUTrackSelection_->filterCandRefs(chargedPFCandidatesInEvent_, true);
387 
388  std::vector<CandidatePtr> allNPU = pileupQcutsPUTrackSelection_->filterCandRefs(chargedPFCandidatesInEvent_);
389  LogTrace("discriminate") << "After track cuts: " << allPU.size();
390 
391  // Now apply the rest of the cuts, like pt, and TIP, tracker hits, etc
392  if (!useAllPFCands_) {
393  std::vector<CandidatePtr> cleanPU = pileupQcutsGeneralQCuts_->filterCandRefs(allPU);
394 
395  std::vector<CandidatePtr> cleanNPU = pileupQcutsGeneralQCuts_->filterCandRefs(allNPU);
396 
397  LogTrace("discriminate") << "After cleaning cuts: " << cleanPU.size();
398 
399  // Only select PU tracks inside the isolation cone.
400  DRFilter deltaBetaFilter(pfTau->p4(), 0, deltaBetaCollectionCone_);
401  for (auto const& cand : cleanPU) {
402  if (deltaBetaFilter(cand))
403  isoPU_.push_back(cand);
404  }
405 
406  for (auto const& cand : cleanNPU) {
407  if (deltaBetaFilter(cand))
408  chPV_.push_back(cand);
409  }
410  LogTrace("discriminate") << "After cone cuts: " << isoPU_.size() << " " << chPV_.size();
411  } else {
412  isoPU_ = std::move(allPU);
413  chPV_ = std::move(allNPU);
414  }
415  }
416 
417  if (calculateWeights_) {
418  for (auto const& isoObject : isoNeutral_) {
419  if (isoObject->charge() != 0) {
420  // weight only neutral objects
421  isoNeutralWeight_.push_back(*isoObject);
422  continue;
423  }
424 
425  double eta = isoObject->eta();
426  double phi = isoObject->phi();
427  double sumNPU = 0.5 * log(weightedSum(chPV_, eta, phi));
428 
429  double sumPU = 0.5 * log(weightedSum(isoPU_, eta, phi));
430  LeafCandidate neutral(*isoObject);
431  if ((sumNPU + sumPU) > 0)
432  neutral.setP4(((sumNPU) / (sumNPU + sumPU)) * neutral.p4());
433 
434  isoNeutralWeight_.push_back(neutral);
435  }
436  }
437 
438  // Check if we want a custom iso cone
439  if (customIsoCone_ >= 0.) {
440  DRFilter filter(pfTau->p4(), 0, customIsoCone_);
441  DRFilter2 filter2(pfTau->p4(), 0, customIsoCone_);
442  std::vector<CandidatePtr> isoCharged_filter;
443  std::vector<CandidatePtr> isoNeutral_filter;
444  CandidateCollection isoNeutralWeight_filter;
445  // Remove all the objects not in our iso cone
446  for (auto const& isoObject : isoCharged_) {
447  if (filter(isoObject))
448  isoCharged_filter.push_back(isoObject);
449  }
450  if (!calculateWeights_) {
451  for (auto const& isoObject : isoNeutral_) {
452  if (filter(isoObject))
453  isoNeutral_filter.push_back(isoObject);
454  }
455  isoNeutral_ = isoNeutral_filter;
456  } else {
457  for (auto const& isoObject : isoNeutralWeight_) {
458  if (filter2(isoObject))
459  isoNeutralWeight_filter.push_back(isoObject);
460  }
461  isoNeutralWeight_ = isoNeutralWeight_filter;
462  }
463  isoCharged_ = isoCharged_filter;
464  }
465 
466  bool failsOccupancyCut = false;
467  bool failsSumPtCut = false;
468  bool failsRelativeSumPtCut = false;
469 
470  //--- nObjects requirement
471  int neutrals = isoNeutral_.size();
472 
473  if (applyDeltaBeta_) {
474  neutrals -= TMath::Nint(deltaBetaFactorThisEvent_ * isoPU_.size());
475  }
476  if (neutrals < 0) {
477  neutrals = 0;
478  }
479 
480  size_t nOccupants = isoCharged_.size() + neutrals;
481 
482  failsOccupancyCut = (nOccupants > maximumOccupancy_);
483 
484  double footprintCorrection_value = 0.;
485  if (applyFootprintCorrection_ || storeRawFootprintCorrection_) {
486  for (std::vector<std::unique_ptr<FootprintCorrection> >::const_iterator footprintCorrection =
487  footprintCorrections_.begin();
488  footprintCorrection != footprintCorrections_.end();
489  ++footprintCorrection) {
490  if ((*footprintCorrection)->selection_(*pfTau)) {
491  footprintCorrection_value = (*footprintCorrection)->offset_(*pfTau);
492  }
493  }
494  }
495 
496  double totalPt = 0.;
497  double puPt = 0.;
498  //--- Sum PT requirement
499  if (applySumPtCut_ || applyRelativeSumPtCut_ || storeRawSumPt_ || storeRawPUsumPt_) {
500  double chargedPt = 0.;
501  double neutralPt = 0.;
502  double weightedNeutralPt = 0.;
503  for (auto const& isoObject : isoCharged_) {
504  //-------------------------------------------------------------------------
505  // CV: fix for Phase-2 HLT tau trigger studies
506  // (pT of PFCandidates within HGCal acceptance is significantly higher than track pT !!)
507  if (enableHGCalWorkaround_) {
508  double trackPt = (isoObject->bestTrack()) ? isoObject->bestTrack()->pt() : 0.;
509  double pfCandPt = isoObject->pt();
510  if (pfCandPt > trackPt) {
511  chargedPt += trackPt;
512  neutralPt += pfCandPt - trackPt;
513  } else {
514  chargedPt += isoObject->pt();
515  }
516  } else {
517  chargedPt += isoObject->pt();
518  }
519  //-------------------------------------------------------------------------
520  }
521  if (!calculateWeights_) {
522  for (auto const& isoObject : isoNeutral_) {
523  neutralPt += isoObject->pt();
524  }
525  } else {
526  for (auto const& isoObject : isoNeutralWeight_) {
527  weightedNeutralPt += isoObject.pt();
528  }
529  }
530  for (auto const& isoObject : isoPU_) {
531  puPt += isoObject->pt();
532  }
533  LogTrace("discriminate") << "chargedPt = " << chargedPt;
534  LogTrace("discriminate") << "neutralPt = " << neutralPt;
535  LogTrace("discriminate") << "weighted neutral Pt = " << weightedNeutralPt;
536  LogTrace("discriminate") << "puPt = " << puPt << " (delta-beta corr. = " << (deltaBetaFactorThisEvent_ * puPt)
537  << ")";
538 
539  if (calculateWeights_) {
540  neutralPt = weightedNeutralPt;
541  }
542 
543  if (applyDeltaBeta_) {
544  neutralPt -= (deltaBetaFactorThisEvent_ * puPt);
545  }
546 
547  if (applyFootprintCorrection_) {
548  neutralPt -= footprintCorrection_value;
549  }
550 
551  if (applyRhoCorrection_) {
552  neutralPt -= rhoThisEvent_;
553  }
554 
555  if (neutralPt < 0.) {
556  neutralPt = 0.;
557  }
558 
559  totalPt = chargedPt + weightGammas_ * neutralPt;
560  LogTrace("discriminate") << "totalPt = " << totalPt << " (cut = " << maximumSumPt_ << ")";
561 
562  failsSumPtCut = (totalPt > maximumSumPt_);
563 
564  //--- Relative Sum PT requirement
565  failsRelativeSumPtCut = (totalPt > ((pfTau->pt() - offsetRelativeSumPt_) * maximumRelativeSumPt_));
566  }
567 
568  bool failsPhotonPtSumOutsideSignalConeCut = false;
569  double photonSumPt_outsideSignalCone = 0.;
570  if (applyPhotonPtSumOutsideSignalConeCut_ || storeRawPhotonSumPt_outsideSignalCone_) {
571  const std::vector<reco::CandidatePtr>& signalGammas = pfTau->signalGammaCands();
572  for (std::vector<reco::CandidatePtr>::const_iterator signalGamma = signalGammas.begin();
573  signalGamma != signalGammas.end();
574  ++signalGamma) {
575  double dR = deltaR(pfTau->eta(), pfTau->phi(), (*signalGamma)->eta(), (*signalGamma)->phi());
576  if (dR > pfTau->signalConeSize())
577  photonSumPt_outsideSignalCone += (*signalGamma)->pt();
578  }
579  if (photonSumPt_outsideSignalCone > maxAbsPhotonSumPt_outsideSignalCone_ ||
580  photonSumPt_outsideSignalCone > (maxRelPhotonSumPt_outsideSignalCone_ * pfTau->pt())) {
581  failsPhotonPtSumOutsideSignalConeCut = true;
582  }
583  }
584 
585  bool fails = (applyOccupancyCut_ && failsOccupancyCut) || (applySumPtCut_ && failsSumPtCut) ||
586  (applyRelativeSumPtCut_ && failsRelativeSumPtCut) ||
587  (applyPhotonPtSumOutsideSignalConeCut_ && failsPhotonPtSumOutsideSignalConeCut);
588 
589  if (pfTau->pt() > minPtForNoIso_ && minPtForNoIso_ > 0.) {
590  return 1.;
591  LogDebug("discriminate") << "tau pt = " << pfTau->pt() << "\t min cutoff pt = " << minPtForNoIso_;
592  }
593 
594  // We did error checking in the constructor, so this is safe.
595  if (storeRawSumPt_) {
596  return totalPt;
597  } else if (storeRawPUsumPt_) {
598  if (applyDeltaBeta_)
599  return puPt;
600  else if (applyRhoCorrection_)
601  return rhoThisEvent_;
602  else
603  return 0.;
604  } else if (storeRawOccupancy_) {
605  return nOccupants;
606  } else if (storeRawFootprintCorrection_) {
607  return footprintCorrection_value;
608  } else if (storeRawPhotonSumPt_outsideSignalCone_) {
609  return photonSumPt_outsideSignalCone;
610  } else {
611  return (fails ? 0. : 1.);
612  }
613 }
614 
616  // pfRecoTauDiscriminationByIsolation
618  desc.add<bool>("storeRawFootprintCorrection", false);
619  desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("pfRecoTauProducer"));
620  desc.add<bool>("storeRawOccupancy", false);
621  desc.add<double>("maximumSumPtCut", 6.0);
622 
623  {
624  edm::ParameterSetDescription pset_signalQualityCuts;
625  pset_signalQualityCuts.add<double>("maxDeltaZ", 0.4);
626  pset_signalQualityCuts.add<double>("minTrackPt", 0.5);
627  pset_signalQualityCuts.add<double>("minTrackVertexWeight", -1.0);
628  pset_signalQualityCuts.add<double>("maxTrackChi2", 100.0);
629  pset_signalQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
630  pset_signalQualityCuts.add<double>("minGammaEt", 1.0);
631  pset_signalQualityCuts.add<unsigned int>("minTrackHits", 3);
632  pset_signalQualityCuts.add<double>("minNeutralHadronEt", 30.0);
633  pset_signalQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
634  pset_signalQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
635 
636  edm::ParameterSetDescription pset_vxAssocQualityCuts;
637  pset_vxAssocQualityCuts.add<double>("minTrackPt", 0.5);
638  pset_vxAssocQualityCuts.add<double>("minTrackVertexWeight", -1.0);
639  pset_vxAssocQualityCuts.add<double>("maxTrackChi2", 100.0);
640  pset_vxAssocQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
641  pset_vxAssocQualityCuts.add<double>("minGammaEt", 1.0);
642  pset_vxAssocQualityCuts.add<unsigned int>("minTrackHits", 3);
643  pset_vxAssocQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
644  pset_vxAssocQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
645 
646  edm::ParameterSetDescription pset_isolationQualityCuts;
647  pset_isolationQualityCuts.add<double>("maxDeltaZ", 0.2);
648  pset_isolationQualityCuts.add<double>("minTrackPt", 1.0);
649  pset_isolationQualityCuts.add<double>("minTrackVertexWeight", -1.0);
650  pset_isolationQualityCuts.add<double>("maxTrackChi2", 100.0);
651  pset_isolationQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
652  pset_isolationQualityCuts.add<double>("minGammaEt", 1.5);
653  pset_isolationQualityCuts.add<unsigned int>("minTrackHits", 8);
654  pset_isolationQualityCuts.add<double>("maxTransverseImpactParameter", 0.03);
655  pset_isolationQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
656 
657  edm::ParameterSetDescription pset_qualityCuts;
658  pset_qualityCuts.add<edm::ParameterSetDescription>("signalQualityCuts", pset_signalQualityCuts);
659  pset_qualityCuts.add<edm::ParameterSetDescription>("vxAssocQualityCuts", pset_vxAssocQualityCuts);
660  pset_qualityCuts.add<edm::ParameterSetDescription>("isolationQualityCuts", pset_isolationQualityCuts);
661  pset_qualityCuts.add<std::string>("leadingTrkOrPFCandOption", "leadPFCand");
662  pset_qualityCuts.add<std::string>("pvFindingAlgo", "closestInDeltaZ");
663  pset_qualityCuts.add<edm::InputTag>("primaryVertexSrc", edm::InputTag("offlinePrimaryVertices"));
664  pset_qualityCuts.add<bool>("vertexTrackFiltering", false);
665  pset_qualityCuts.add<bool>("recoverLeadingTrk", false);
666 
667  desc.add<edm::ParameterSetDescription>("qualityCuts", pset_qualityCuts);
668  }
669 
670  desc.add<double>("minTauPtForNoIso", -99.0);
671  desc.add<double>("maxAbsPhotonSumPt_outsideSignalCone", 1000000000.0);
672  desc.add<edm::InputTag>("vertexSrc", edm::InputTag("offlinePrimaryVertices"));
673  desc.add<bool>("applySumPtCut", false);
674  desc.add<double>("rhoConeSize", 0.5);
675  desc.add<bool>("ApplyDiscriminationByTrackerIsolation", true);
676  desc.add<bool>("storeRawPhotonSumPt_outsideSignalCone", false);
677  desc.add<edm::InputTag>("rhoProducer", edm::InputTag("fixedGridRhoFastjetAll"));
678  desc.add<bool>("enableHGCalWorkaround", false);
679 
680  {
682  vpsd1.add<std::string>("selection");
683  vpsd1.add<std::string>("offset");
684  desc.addVPSet("footprintCorrections", vpsd1, {});
685  }
686 
687  desc.add<std::string>("deltaBetaFactor", "0.38");
688  desc.add<bool>("applyFootprintCorrection", false);
689  desc.add<bool>("UseAllPFCandsForWeights", false);
690  desc.add<double>("relativeSumPtCut", 0.0);
691  {
692  edm::ParameterSetDescription pset_Prediscriminants;
693  pset_Prediscriminants.add<std::string>("BooleanOperator", "and");
694  {
696  psd1.add<double>("cut");
697  psd1.add<edm::InputTag>("Producer");
698  pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("leadTrack", psd1);
699  }
700  {
701  // encountered this at
702  // RecoTauTag/Configuration/python/HPSPFTaus_cff.py
703  // Prediscriminants = requireDecayMode.clone(),
704  // requireDecayMode = cms.PSet(
705  // BooleanOperator = cms.string("and"),
706  // decayMode = cms.PSet(
707  // Producer = cms.InputTag('hpsPFTauDiscriminationByDecayModeFindingNewDMs'),
708  // cut = cms.double(0.5)
709  // )
710  // )
712  psd1.add<double>("cut");
713  psd1.add<edm::InputTag>("Producer");
714  pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("decayMode", psd1);
715  }
716  {
717  // encountered this at
718  // RecoTauTag/Configuration/python/HPSPFTaus_cff.py
719  // Prediscriminants = requireDecayMode.clone(),
720  // hpsPFTauDiscriminationByLooseIsolation.Prediscriminants.preIso = cms.PSet(
721  // Producer = cms.InputTag("hpsPFTauDiscriminationByLooseChargedIsolation"),
722  // cut = cms.double(0.5)
723  // )
725  psd1.add<double>("cut");
726  psd1.add<edm::InputTag>("Producer");
727  pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("preIso", psd1);
728  }
729  desc.add<edm::ParameterSetDescription>("Prediscriminants", pset_Prediscriminants);
730  }
731 
732  desc.add<unsigned int>("maximumOccupancy", 0);
733  desc.add<int>("verbosity", 0);
734 
735  desc.add<bool>("applyOccupancyCut", true);
736  desc.add<bool>("applyDeltaBetaCorrection", false);
737  desc.add<bool>("applyRelativeSumPtCut", false);
738  desc.add<bool>("storeRawPUsumPt", false);
739  desc.add<bool>("applyPhotonPtSumOutsideSignalConeCut", false);
740  desc.add<bool>("deltaBetaPUTrackPtCutOverride", false);
741  desc.add<bool>("ApplyDiscriminationByWeightedECALIsolation", false);
742  desc.add<bool>("storeRawSumPt", false);
743  desc.add<bool>("ApplyDiscriminationByECALIsolation", true);
744  desc.add<bool>("applyRhoCorrection", false);
745 
746  desc.add<double>("WeightECALIsolation", 1.0);
747  desc.add<double>("rhoUEOffsetCorrection", 1.0);
748  desc.add<double>("maxRelPhotonSumPt_outsideSignalCone", 0.1);
749  desc.add<double>("deltaBetaPUTrackPtCutOverride_val", -1.5);
750  desc.add<double>("isoConeSizeForDeltaBeta", 0.5);
751  desc.add<double>("relativeSumPtOffset", 0.0);
752  desc.add<double>("customOuterCone", -1.0);
753  desc.add<edm::InputTag>("particleFlowSrc", edm::InputTag("particleFlow"));
754 
755  descriptions.add("pfRecoTauDiscriminationByIsolation", desc);
756 }
757 
ConfigurationDescriptions.h
PFRecoTauDiscriminationByIsolation::FootprintCorrection
Definition: PFRecoTauDiscriminationByIsolation.cc:222
PFRecoTauDiscriminationByIsolation::discriminate
double discriminate(const PFTauRef &pfTau) const override
Definition: PFRecoTauDiscriminationByIsolation.cc:306
zmumugammaAnalyzer_cfi.pfCandidates
pfCandidates
Definition: zmumugammaAnalyzer_cfi.py:11
PFRecoTauDiscriminationByIsolation::FootprintCorrection::offset_
StringObjectFunction< PFTau > offset_
Definition: PFRecoTauDiscriminationByIsolation.cc:227
mps_fire.i
i
Definition: mps_fire.py:355
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
StringObjectFunction< PFTau >
TauDiscriminationProducerBase.h
reco::tau::RecoTauQualityCuts
Definition: RecoTauQualityCuts.h:34
PFRecoTauDiscriminationByIsolation::storeRawFootprintCorrection_
bool storeRawFootprintCorrection_
Definition: PFRecoTauDiscriminationByIsolation.cc:235
PFRecoTauDiscriminationByIsolation::deltaBetaCollectionCone_
double deltaBetaCollectionCone_
Definition: PFRecoTauDiscriminationByIsolation.cc:251
PFRecoTauDiscriminationByIsolation::includeGammas_
bool includeGammas_
Definition: PFRecoTauDiscriminationByIsolation.cc:202
min
T min(T a, T b)
Definition: MathUtil.h:58
edm::EDGetTokenT
Definition: EDGetToken.h:33
edm
HLT enums.
Definition: AlignableModifier.h:19
gather_cfg.cout
cout
Definition: gather_cfg.py:144
PFRecoTauDiscriminationByIsolation::maximumOccupancy_
uint32_t maximumOccupancy_
Definition: PFRecoTauDiscriminationByIsolation.cc:207
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
PFRecoTauDiscriminationByIsolation::chargedPFCandidatesInEvent_
std::vector< reco::CandidatePtr > chargedPFCandidatesInEvent_
Definition: PFRecoTauDiscriminationByIsolation.cc:249
edm::VParameterSet
std::vector< ParameterSet > VParameterSet
Definition: ParameterSet.h:33
PFRecoTauDiscriminationByIsolation::moduleLabel_
std::string moduleLabel_
Definition: PFRecoTauDiscriminationByIsolation.cc:190
PFRecoTauDiscriminationByIsolation::weightedSum
double weightedSum(const std::vector< CandidatePtr > &inColl_, double eta, double phi) const
Definition: PFRecoTauDiscriminationByIsolation.cc:177
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
ConeTools.h
PFRecoTauDiscriminationByIsolation::useAllPFCands_
bool useAllPFCands_
Definition: PFRecoTauDiscriminationByIsolation.cc:257
HLT_2018_cff.deltaBetaPUTrackPtCutOverride
deltaBetaPUTrackPtCutOverride
Definition: HLT_2018_cff.py:31433
edm::Handle
Definition: AssociativeIterator.h:50
edm::ParameterSetDescription::addOptional
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:105
PFRecoTauDiscriminationByIsolation::pileupQcutsPUTrackSelection_
std::unique_ptr< tau::RecoTauQualityCuts > pileupQcutsPUTrackSelection_
Definition: PFRecoTauDiscriminationByIsolation.cc:196
PFRecoTauDiscriminationByIsolation::rhoProducer_
edm::InputTag rhoProducer_
Definition: PFRecoTauDiscriminationByIsolation.cc:258
RecoTauVertexAssociator.h
edm::Ref< PFTauCollection >
PFRecoTauDiscriminationByIsolation::maxAbsPhotonSumPt_outsideSignalCone_
double maxAbsPhotonSumPt_outsideSignalCone_
Definition: PFRecoTauDiscriminationByIsolation.cc:218
PFRecoTauDiscriminationByIsolation::maxRelPhotonSumPt_outsideSignalCone_
double maxRelPhotonSumPt_outsideSignalCone_
Definition: PFRecoTauDiscriminationByIsolation.cc:219
PFRecoTauDiscriminationByIsolation::FootprintCorrection::selection_
StringCutObjectSelector< PFTau > selection_
Definition: PFRecoTauDiscriminationByIsolation.cc:226
PFRecoTauDiscriminationByIsolation::qualityCutsPSet_
edm::ParameterSet qualityCutsPSet_
Definition: PFRecoTauDiscriminationByIsolation.cc:192
PFRecoTauDiscriminationByIsolation::verbosity_
int verbosity_
Definition: PFRecoTauDiscriminationByIsolation.cc:266
reco::tau::RecoTauVertexAssociator
Definition: RecoTauVertexAssociator.h:50
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
PFRecoTauDiscriminationByIsolation::rhoThisEvent_
double rhoThisEvent_
Definition: PFRecoTauDiscriminationByIsolation.cc:263
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
reco::Candidate::charge
virtual int charge() const =0
electric charge
PFRecoTauDiscriminationByIsolation::FootprintCorrection::~FootprintCorrection
~FootprintCorrection()
Definition: PFRecoTauDiscriminationByIsolation.cc:225
PFRecoTauDiscriminationByIsolation::storeRawPhotonSumPt_outsideSignalCone_
bool storeRawPhotonSumPt_outsideSignalCone_
Definition: PFRecoTauDiscriminationByIsolation.cc:236
PVValHelper::eta
Definition: PVValidationHelpers.h:69
PFRecoTauDiscriminationByIsolation::vertexAssociator_
std::unique_ptr< tau::RecoTauVertexAssociator > vertexAssociator_
Definition: PFRecoTauDiscriminationByIsolation.cc:199
fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
corrVsCorr.selection
selection
main part
Definition: corrVsCorr.py:100
HLT_2018_cff.deltaBetaPUTrackPtCutOverride_val
deltaBetaPUTrackPtCutOverride_val
Definition: HLT_2018_cff.py:31453
LeafCandidate.h
TauDiscriminationProducerBase
Definition: TauDiscriminationProducerBase.h:55
ParameterSetDescription.h
ALCARECOTkAlBeamHalo_cff.filter
filter
Definition: ALCARECOTkAlBeamHalo_cff.py:27
PFRecoTauDiscriminationByIsolation::qcuts_
std::unique_ptr< tau::RecoTauQualityCuts > qcuts_
Definition: PFRecoTauDiscriminationByIsolation.cc:193
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Vertex.h
RecoTauQualityCuts.h
PFRecoTauDiscriminationByIsolation::enableHGCalWorkaround_
bool enableHGCalWorkaround_
Definition: PFRecoTauDiscriminationByIsolation.cc:204
PFRecoTauDiscriminationByIsolation::applyOccupancyCut_
bool applyOccupancyCut_
Definition: PFRecoTauDiscriminationByIsolation.cc:206
edm::OwnVector::reserve
void reserve(size_t)
Definition: OwnVector.h:320
PFRecoTauDiscriminationByIsolation::vertex_token
edm::EDGetTokenT< reco::VertexCollection > vertex_token
Definition: PFRecoTauDiscriminationByIsolation.cc:248
PFRecoTauDiscriminationByIsolation::applyDeltaBeta_
bool applyDeltaBeta_
Definition: PFRecoTauDiscriminationByIsolation.cc:243
PFRecoTauDiscriminationByIsolation::maximumSumPt_
double maximumSumPt_
Definition: PFRecoTauDiscriminationByIsolation.cc:209
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
edm::ParameterSet
Definition: ParameterSet.h:36
PFRecoTauDiscriminationByIsolation::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: PFRecoTauDiscriminationByIsolation.cc:615
reco::tau::cone::DeltaRPtrFilter
Definition: ConeTools.h:33
PFRecoTauDiscriminationByIsolation::rhoConeSize_
double rhoConeSize_
Definition: PFRecoTauDiscriminationByIsolation.cc:260
PFRecoTauDiscriminationByIsolation::storeRawOccupancy_
bool storeRawOccupancy_
Definition: PFRecoTauDiscriminationByIsolation.cc:232
ParameterSet
Definition: Functions.h:16
PFRecoTauDiscriminationByIsolation::PFRecoTauDiscriminationByIsolation
PFRecoTauDiscriminationByIsolation(const edm::ParameterSet &pset)
Definition: PFRecoTauDiscriminationByIsolation.cc:30
edm::ParameterSetDescription::addVPSet
ParameterDescriptionBase * addVPSet(U const &iLabel, ParameterSetDescription const &validator, std::vector< ParameterSet > const &defaults)
Definition: ParameterSetDescription.h:149
PFRecoTauDiscriminationByIsolation::calculateWeights_
bool calculateWeights_
Definition: PFRecoTauDiscriminationByIsolation.cc:203
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
PFRecoTauDiscriminationByIsolation::minPtForNoIso_
double minPtForNoIso_
Definition: PFRecoTauDiscriminationByIsolation.cc:215
reco::tau::cone::DeltaRFilter
Definition: ConeTools.h:15
PFRecoTauDiscriminationByIsolation::applyPhotonPtSumOutsideSignalConeCut_
bool applyPhotonPtSumOutsideSignalConeCut_
Definition: PFRecoTauDiscriminationByIsolation.cc:217
PFRecoTauDiscriminationByIsolation::pileupQcutsGeneralQCuts_
std::unique_ptr< tau::RecoTauQualityCuts > pileupQcutsGeneralQCuts_
Definition: PFRecoTauDiscriminationByIsolation.cc:197
PFRecoTauDiscriminationByIsolation::storeRawSumPt_
bool storeRawSumPt_
Definition: PFRecoTauDiscriminationByIsolation.cc:233
cand
Definition: decayParser.h:34
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
PFRecoTauDiscriminationByIsolation::rho_token
edm::EDGetTokenT< double > rho_token
Definition: PFRecoTauDiscriminationByIsolation.cc:259
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:114
edm::EventSetup
Definition: EventSetup.h:57
reco::tau::factorizePUQCuts
std::pair< edm::ParameterSet, edm::ParameterSet > factorizePUQCuts(const edm::ParameterSet &inputSet)
Definition: RecoTauQualityCuts.cc:384
PFRecoTauDiscriminationByIsolation::storeRawPUsumPt_
bool storeRawPUsumPt_
Definition: PFRecoTauDiscriminationByIsolation.cc:234
PFRecoTauDiscriminationByIsolation
Definition: PFRecoTauDiscriminationByIsolation.cc:28
edm::Ptr< Candidate >
PFRecoTauDiscriminationByIsolation::applySumPtCut_
bool applySumPtCut_
Definition: PFRecoTauDiscriminationByIsolation.cc:208
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
PFRecoTauDiscriminationByIsolation::vertexSrc_
edm::InputTag vertexSrc_
Definition: PFRecoTauDiscriminationByIsolation.cc:247
PFRecoTauDiscriminationByIsolation::pfCand_token
edm::EDGetTokenT< edm::View< reco::Candidate > > pfCand_token
Definition: PFRecoTauDiscriminationByIsolation.cc:245
PFRecoTauDiscriminationByIsolation::includeTracks_
bool includeTracks_
Definition: PFRecoTauDiscriminationByIsolation.cc:201
PFRecoTauDiscriminationByIsolation::deltaBetaFormula_
std::unique_ptr< TFormula > deltaBetaFormula_
Definition: PFRecoTauDiscriminationByIsolation.cc:252
reco::LeafCandidate::setP4
void setP4(const LorentzVector &p4) final
set 4-momentum
Definition: LeafCandidate.h:158
PFRecoTauDiscriminationByIsolation::maximumRelativeSumPt_
double maximumRelativeSumPt_
Definition: PFRecoTauDiscriminationByIsolation.cc:211
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
PFRecoTauDiscriminationByIsolation::beginEvent
void beginEvent(const edm::Event &evt, const edm::EventSetup &evtSetup) override
Definition: PFRecoTauDiscriminationByIsolation.cc:269
StringCutObjectSelector.h
PFRecoTauDiscriminationByIsolation::rhoUEOffsetCorrection_
double rhoUEOffsetCorrection_
Definition: PFRecoTauDiscriminationByIsolation.cc:261
PFRecoTauDiscriminationByIsolation::applyRelativeSumPtCut_
bool applyRelativeSumPtCut_
Definition: PFRecoTauDiscriminationByIsolation.cc:210
PFRecoTauDiscriminationByIsolation::~PFRecoTauDiscriminationByIsolation
~PFRecoTauDiscriminationByIsolation() override
Definition: PFRecoTauDiscriminationByIsolation.cc:172
StringCutObjectSelector< PFTau >
Exception
Definition: hltDiff.cc:246
options_cfi.eventSetup
eventSetup
Definition: options_cfi.py:12
PFRecoTauDiscriminationByIsolation::deltaBetaFactorThisEvent_
double deltaBetaFactorThisEvent_
Definition: PFRecoTauDiscriminationByIsolation.cc:253
PFRecoTauDiscriminationByIsolation::offsetRelativeSumPt_
double offsetRelativeSumPt_
Definition: PFRecoTauDiscriminationByIsolation.cc:212
PFRecoTauDiscriminationByIsolation::applyFootprintCorrection_
bool applyFootprintCorrection_
Definition: PFRecoTauDiscriminationByIsolation.cc:221
reco::deltaR
constexpr auto deltaR(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:30
PFRecoTauDiscriminationByIsolation::footprintCorrections_
std::vector< std::unique_ptr< FootprintCorrection > > footprintCorrections_
Definition: PFRecoTauDiscriminationByIsolation.cc:229
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
edm::OwnVector::push_back
void push_back(D *&d)
Definition: OwnVector.h:326
PFRecoTauDiscriminationByIsolation::applyRhoCorrection_
bool applyRhoCorrection_
Definition: PFRecoTauDiscriminationByIsolation.cc:256
PFRecoTauDiscriminationByIsolation::weightGammas_
double weightGammas_
Definition: PFRecoTauDiscriminationByIsolation.cc:205
MillePedeFileConverter_cfg.out
out
Definition: MillePedeFileConverter_cfg.py:31
reco::LeafCandidate
Definition: LeafCandidate.h:16
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
HGC3DClusterGenMatchSelector_cfi.dR
dR
Definition: HGC3DClusterGenMatchSelector_cfi.py:7
PFRecoTauDiscriminationByIsolation::pfCandSrc_
edm::InputTag pfCandSrc_
Definition: PFRecoTauDiscriminationByIsolation.cc:244
PFRecoTauDiscriminationByIsolation::rhoCorrectionThisEvent_
double rhoCorrectionThisEvent_
Definition: PFRecoTauDiscriminationByIsolation.cc:262
event
Definition: event.py:1
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:82
edm::Event
Definition: Event.h:73
StringObjectFunction.h
edm::OwnVector::size
size_type size() const
Definition: OwnVector.h:300
listHistos.trackPt
trackPt
Definition: listHistos.py:120
edm::InputTag
Definition: InputTag.h:15
PFRecoTauDiscriminationByIsolation::FootprintCorrection::FootprintCorrection
FootprintCorrection(const std::string &selection, const std::string &offset)
Definition: PFRecoTauDiscriminationByIsolation.cc:223
edm::ParameterSet::getParameterSet
ParameterSet const & getParameterSet(std::string const &) const
Definition: ParameterSet.cc:2121
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
edm::OwnVector
Definition: OwnVector.h:24
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
PFRecoTauDiscriminationByIsolation::customIsoCone_
double customIsoCone_
Definition: PFRecoTauDiscriminationByIsolation.cc:213