CMS 3D CMS Logo
PFJetIDSelectionFunctor.h
Go to the documentation of this file.
1 #ifndef PhysicsTools_SelectorUtils_interface_PFJetIDSelectionFunctor_h
2 #define PhysicsTools_SelectorUtils_interface_PFJetIDSelectionFunctor_h
3 
15 #ifndef __GCCXML__
16 #include "FWCore/Framework/interface/ConsumesCollector.h"
17 #endif
18 #include "DataFormats/PatCandidates/interface/Jet.h"
19 #include "FWCore/MessageLogger/interface/MessageLogger.h"
20 
21 #include "PhysicsTools/SelectorUtils/interface/Selector.h"
22 
23 #include <TMath.h>
24 
25 class PFJetIDSelectionFunctor : public Selector<pat::Jet> {
26 public: // interface
27  enum Version_t { FIRSTDATA, RUNIISTARTUP, WINTER16, WINTER17, WINTER17PUPPI, SUMMER18, SUMMER18PUPPI, N_VERSIONS };
28  enum Quality_t { LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY };
29 
30  PFJetIDSelectionFunctor() {}
31 
32 #ifndef __GCCXML__
33  PFJetIDSelectionFunctor(edm::ParameterSet const &params, edm::ConsumesCollector &iC)
34  : PFJetIDSelectionFunctor(params) {}
35 #endif
36 
37  PFJetIDSelectionFunctor(edm::ParameterSet const &params) {
38  std::string versionStr = params.getParameter<std::string>("version");
39  std::string qualityStr = params.getParameter<std::string>("quality");
40 
41  if (versionStr == "FIRSTDATA")
42  version_ = FIRSTDATA;
43  else if (versionStr == "RUNIISTARTUP")
44  version_ = RUNIISTARTUP;
45  // WINTER16 implements most recent (as of Feb 2017) JetID criteria
46  // See: https://twiki.cern.ch/twiki/bin/view/CMS/JetID13TeVRun2016
47  else if (versionStr == "WINTER16")
48  version_ = WINTER16;
49  else if (versionStr == "WINTER17")
50  version_ = WINTER17;
51  else if (versionStr == "WINTER17PUPPI")
52  version_ = WINTER17PUPPI;
53  else if (versionStr == "SUMMER18")
54  version_ = SUMMER18;
55  else if (versionStr == "SUMMER18PUPPI")
56  version_ = SUMMER18PUPPI;
57  else
58  version_ = WINTER17; //set WINTER17 as default
59 
60  if (qualityStr == "LOOSE")
61  quality_ = LOOSE;
62  else if (qualityStr == "TIGHT")
63  quality_ = TIGHT;
64  else if (qualityStr == "TIGHTLEPVETO")
65  quality_ = TIGHTLEPVETO;
66  else
67  quality_ = TIGHT;
68 
69  initCuts();
70 
71  // Now check the configuration to see if the user changed anything
72  if (params.exists("CHF"))
73  set("CHF", params.getParameter<double>("CHF"));
74  if (params.exists("NHF"))
75  set("NHF", params.getParameter<double>("NHF"));
76  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI) ||
77  quality_ != TIGHT) {
78  if (params.exists("CEF"))
79  set("CEF", params.getParameter<double>("CEF"));
80  }
81  if (params.exists("NEF"))
82  set("NEF", params.getParameter<double>("NEF"));
83  if (params.exists("NCH"))
84  set("NCH", params.getParameter<int>("NCH"));
85  if (params.exists("nConstituents"))
86  set("nConstituents", params.getParameter<int>("nConstituents"));
87  if (version_ == RUNIISTARTUP) {
88  if (params.exists("NEF_FW"))
89  set("NEF_FW", params.getParameter<double>("NEF_FW"));
90  if (params.exists("nNeutrals_FW"))
91  set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
92  }
93  if (version_ == WINTER16) {
94  if (params.exists("NHF_EC"))
95  set("NHF_EC", params.getParameter<double>("NHF_EC"));
96  if (params.exists("NEF_EC"))
97  set("NEF_EC", params.getParameter<double>("NEF_EC"));
98  if (params.exists("nNeutrals_EC"))
99  set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
100  if (params.exists("NEF_FW"))
101  set("NEF_FW", params.getParameter<double>("NEF_FW"));
102  if (params.exists("nNeutrals_FW"))
103  set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
104  if (quality_ == TIGHTLEPVETO) {
105  if (params.exists("MUF"))
106  set("MUF", params.getParameter<double>("MUF"));
107  }
108  }
109  if (version_ == WINTER17) {
110  if (params.exists("NEF_EC_L"))
111  set("NEF_EC_L", params.getParameter<double>("NEF_EC_L"));
112  if (params.exists("NEF_EC_U"))
113  set("NEF_EC_U", params.getParameter<double>("NEF_EC_U"));
114  if (params.exists("nNeutrals_EC"))
115  set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
116  if (params.exists("NHF_FW"))
117  set("NHF_FW", params.getParameter<double>("NHF_FW"));
118  if (params.exists("NEF_FW"))
119  set("NEF_FW", params.getParameter<double>("NEF_FW"));
120  if (params.exists("nNeutrals_FW"))
121  set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
122  if (quality_ == TIGHTLEPVETO) {
123  if (params.exists("MUF"))
124  set("MUF", params.getParameter<double>("MUF"));
125  }
126  }
127  if (version_ == WINTER17PUPPI) {
128  if (params.exists("NHF_EC"))
129  set("NHF_EC", params.getParameter<double>("NHF_EC"));
130  if (params.exists("NHF_FW"))
131  set("NHF_FW", params.getParameter<double>("NHF_FW"));
132  if (params.exists("NEF_FW"))
133  set("NEF_FW", params.getParameter<double>("NEF_FW"));
134  if (params.exists("nNeutrals_FW_L"))
135  set("nNeutrals_FW_L", params.getParameter<int>("nNeutrals_FW_L"));
136  if (params.exists("nNeutrals_FW_U"))
137  set("nNeutrals_FW_U", params.getParameter<int>("nNeutrals_FW_U"));
138  if (quality_ == TIGHTLEPVETO) {
139  if (params.exists("MUF"))
140  set("MUF", params.getParameter<double>("MUF"));
141  }
142  }
143  if (version_ == SUMMER18) {
144  if (params.exists("NHF_TR"))
145  set("NHF_TR", params.getParameter<double>("NHF_TR"));
146  if (params.exists("NEF_TR"))
147  set("NEF_TR", params.getParameter<double>("NEF_TR"));
148  if (params.exists("NCH_TR"))
149  set("NCH_TR", params.getParameter<int>("NCH_TR"));
150  if (params.exists("NEF_EC_L"))
151  set("NEF_EC_L", params.getParameter<double>("NEF_EC_L"));
152  if (params.exists("NEF_EC_U"))
153  set("NEF_EC_U", params.getParameter<double>("NEF_EC_U"));
154  if (params.exists("nNeutrals_EC"))
155  set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
156  if (params.exists("NHF_FW"))
157  set("NHF_FW", params.getParameter<double>("NHF_FW"));
158  if (params.exists("NEF_FW"))
159  set("NEF_FW", params.getParameter<double>("NEF_FW"));
160  if (params.exists("nNeutrals_FW"))
161  set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
162  if (quality_ == TIGHTLEPVETO) {
163  if (params.exists("MUF"))
164  set("MUF", params.getParameter<double>("MUF"));
165  if (params.exists("MUF_TR"))
166  set("MUF_TR", params.getParameter<double>("MUF_TR"));
167  if (params.exists("CEF_TR"))
168  set("CEF_TR", params.getParameter<double>("CEF_TR"));
169  }
170  }
171  if (version_ == SUMMER18PUPPI) {
172  if (params.exists("NHF_TR"))
173  set("NHF_TR", params.getParameter<double>("NHF_TR"));
174  if (params.exists("NEF_TR"))
175  set("NEF_TR", params.getParameter<double>("NEF_TR"));
176  if (params.exists("NHF_EC"))
177  set("NHF_EC", params.getParameter<double>("NHF_EC"));
178  if (params.exists("NHF_FW"))
179  set("NHF_FW", params.getParameter<double>("NHF_FW"));
180  if (params.exists("NEF_FW"))
181  set("NEF_FW", params.getParameter<double>("NEF_FW"));
182  if (params.exists("nNeutrals_FW_L"))
183  set("nNeutrals_FW_L", params.getParameter<int>("nNeutrals_FW_L"));
184  if (params.exists("nNeutrals_FW_U"))
185  set("nNeutrals_FW_U", params.getParameter<int>("nNeutrals_FW_U"));
186  if (quality_ == TIGHTLEPVETO) {
187  if (params.exists("MUF"))
188  set("MUF", params.getParameter<double>("MUF"));
189  if (params.exists("MUF_TR"))
190  set("MUF_TR", params.getParameter<double>("MUF_TR"));
191  if (params.exists("CEF_TR"))
192  set("CEF_TR", params.getParameter<double>("CEF_TR"));
193  }
194  }
195 
196  if (params.exists("cutsToIgnore"))
197  setIgnoredCuts(params.getParameter<std::vector<std::string> >("cutsToIgnore"));
198 
199  initIndex();
200  }
201 
202  PFJetIDSelectionFunctor(Version_t version, Quality_t quality) : version_(version), quality_(quality) {
203  initCuts();
204  initIndex();
205  }
206 
207  //
208  // Accessor from PAT jets
209  //
210  bool operator()(const pat::Jet &jet, pat::strbitset &ret) override {
211  if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
212  version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI) {
213  if (jet.currentJECLevel() == "Uncorrected" || !jet.jecSetsAvailable())
214  return firstDataCuts(jet, ret, version_);
215  else
216  return firstDataCuts(jet.correctedJet("Uncorrected"), ret, version_);
217  } else {
218  return false;
219  }
220  }
221  using Selector<pat::Jet>::operator();
222 
223  //
224  // Accessor from *CORRECTED* 4-vector, EMF, and Jet ID.
225  // This can be used with reco quantities.
226  //
227  bool operator()(const reco::PFJet &jet, pat::strbitset &ret) {
228  if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
229  version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI) {
230  return firstDataCuts(jet, ret, version_);
231  } else {
232  return false;
233  }
234  }
235 
236  bool operator()(const reco::PFJet &jet) {
237  retInternal_.set(false);
238  operator()(jet, retInternal_);
239  setIgnored(retInternal_);
240  return (bool)retInternal_;
241  }
242 
243  //
244  // cuts based on craft 08 analysis.
245  //
246  bool firstDataCuts(reco::Jet const &jet, pat::strbitset &ret, Version_t version_) {
247  ret.set(false);
248 
249  // cache some variables
250  double chf = 0.0;
251  double nhf = 0.0;
252  double cef = 0.0;
253  double nef = 0.0;
254  double muf = 0.0;
255 
256  int nch = 0;
257  int nconstituents = 0;
258  int nneutrals = 0;
259 
260  // Have to do this because pat::Jet inherits from reco::Jet but not reco::PFJet
261  reco::PFJet const *pfJet = dynamic_cast<reco::PFJet const *>(&jet);
262  pat::Jet const *patJet = dynamic_cast<pat::Jet const *>(&jet);
263  reco::BasicJet const *basicJet = dynamic_cast<reco::BasicJet const *>(&jet);
264 
265  if (patJet != nullptr) {
266  if (patJet->isPFJet()) {
267  chf = patJet->chargedHadronEnergyFraction();
268  nhf = patJet->neutralHadronEnergyFraction();
269  cef = patJet->chargedEmEnergyFraction();
270  nef = patJet->neutralEmEnergyFraction();
271  nch = patJet->chargedMultiplicity();
272  muf = patJet->muonEnergyFraction();
273  nconstituents = patJet->neutralMultiplicity() + patJet->chargedMultiplicity();
274  nneutrals = patJet->neutralMultiplicity();
275  }
276  // Handle the special case where this is a composed jet for
277  // subjet analyses
278  else if (patJet->isBasicJet()) {
279  double e_chf = 0.0;
280  double e_nhf = 0.0;
281  double e_cef = 0.0;
282  double e_nef = 0.0;
283  double e_muf = 0.0;
284  nch = 0;
285  nconstituents = 0;
286  nneutrals = 0;
287 
288  for (reco::Jet::const_iterator ibegin = patJet->begin(), iend = patJet->end(), isub = ibegin; isub != iend;
289  ++isub) {
290  reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
291  pat::Jet const *patsub = dynamic_cast<pat::Jet const *>(&*isub);
292  if (patsub) {
293  e_chf += patsub->chargedHadronEnergy();
294  e_nhf += patsub->neutralHadronEnergy();
295  e_cef += patsub->chargedEmEnergy();
296  e_nef += patsub->neutralEmEnergy();
297  e_muf += patsub->muonEnergy();
298  nch += patsub->chargedMultiplicity();
299  nconstituents += patsub->neutralMultiplicity() + patsub->chargedMultiplicity();
300  nneutrals += patsub->neutralMultiplicity();
301  } else if (pfsub) {
302  e_chf += pfsub->chargedHadronEnergy();
303  e_nhf += pfsub->neutralHadronEnergy();
304  e_cef += pfsub->chargedEmEnergy();
305  e_nef += pfsub->neutralEmEnergy();
306  e_muf += pfsub->muonEnergy();
307  nch += pfsub->chargedMultiplicity();
308  nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
309  nneutrals += pfsub->neutralMultiplicity();
310  } else
311  assert(0);
312  }
313  double e = patJet->energy();
314  if (e > 0.000001) {
315  chf = e_chf / e;
316  nhf = e_nhf / e;
317  cef = e_cef / e;
318  nef = e_nef / e;
319  muf = e_muf / e;
320  } else {
321  chf = nhf = cef = nef = muf = 0.0;
322  }
323  }
324  } // end if pat jet
325  else if (pfJet != nullptr) {
326  // CV: need to compute energy fractions in a way that works for corrected as well as for uncorrected PFJets
327  double jetEnergyUncorrected = pfJet->chargedHadronEnergy() + pfJet->neutralHadronEnergy() +
328  pfJet->photonEnergy() + pfJet->electronEnergy() + pfJet->muonEnergy() +
329  pfJet->HFEMEnergy();
330  if (jetEnergyUncorrected > 0.) {
331  chf = pfJet->chargedHadronEnergy() / jetEnergyUncorrected;
332  nhf = pfJet->neutralHadronEnergy() / jetEnergyUncorrected;
333  cef = pfJet->chargedEmEnergy() / jetEnergyUncorrected;
334  nef = pfJet->neutralEmEnergy() / jetEnergyUncorrected;
335  muf = pfJet->muonEnergy() / jetEnergyUncorrected;
336  }
337  nch = pfJet->chargedMultiplicity();
338  nconstituents = pfJet->neutralMultiplicity() + pfJet->chargedMultiplicity();
339  nneutrals = pfJet->neutralMultiplicity();
340  } // end if PF jet
341  // Handle the special case where this is a composed jet for
342  // subjet analyses
343  else if (basicJet != nullptr) {
344  double e_chf = 0.0;
345  double e_nhf = 0.0;
346  double e_cef = 0.0;
347  double e_nef = 0.0;
348  double e_muf = 0.0;
349  nch = 0;
350  nconstituents = 0;
351  for (reco::Jet::const_iterator ibegin = basicJet->begin(), iend = patJet->end(), isub = ibegin; isub != iend;
352  ++isub) {
353  reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
354  e_chf += pfsub->chargedHadronEnergy();
355  e_nhf += pfsub->neutralHadronEnergy();
356  e_cef += pfsub->chargedEmEnergy();
357  e_nef += pfsub->neutralEmEnergy();
358  e_muf += pfsub->muonEnergy();
359  nch += pfsub->chargedMultiplicity();
360  nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
361  nneutrals += pfsub->neutralMultiplicity();
362  }
363  double e = basicJet->energy();
364  if (e > 0.000001) {
365  chf = e_chf / e;
366  nhf = e_nhf / e;
367  cef = e_cef / e;
368  nef = e_nef / e;
369  muf = e_muf / e;
370  }
371  } // end if basic jet
372 
373  float etaB = 2.4;
374  // Cuts for |eta| < 2.6 for Summer18
375  if (version_ == SUMMER18 || version_ == SUMMER18PUPPI)
376  etaB = 2.6;
377  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI) ||
378  quality_ != TIGHT) {
379  if (ignoreCut(indexCEF_) || (cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > etaB))
380  passCut(ret, indexCEF_);
381  }
382  if (ignoreCut(indexCHF_) || (chf > cut(indexCHF_, double()) || std::abs(jet.eta()) > etaB))
383  passCut(ret, indexCHF_);
384  if (ignoreCut(indexNCH_) || (nch > cut(indexNCH_, int()) || std::abs(jet.eta()) > etaB))
385  passCut(ret, indexNCH_);
386  if (version_ == FIRSTDATA) { // Cuts for all eta for FIRSTDATA
387  if (ignoreCut(indexNConstituents_) || (nconstituents > cut(indexNConstituents_, int())))
388  passCut(ret, indexNConstituents_);
389  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double())))
390  passCut(ret, indexNEF_);
391  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double())))
392  passCut(ret, indexNHF_);
393  } else if (version_ == RUNIISTARTUP) {
394  // Cuts for |eta| <= 3.0 for RUNIISTARTUP scenario
395  if (ignoreCut(indexNConstituents_) ||
396  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 3.0))
397  passCut(ret, indexNConstituents_);
398  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 3.0))
399  passCut(ret, indexNEF_);
400  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 3.0))
401  passCut(ret, indexNHF_);
402  // Cuts for |eta| > 3.0 for RUNIISTARTUP scenario
403  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
404  passCut(ret, indexNEF_FW_);
405  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
406  passCut(ret, indexNNeutrals_FW_);
407  } else if (version_ == WINTER16) {
408  // Cuts for |eta| <= 2.7 for WINTER16 scenario
409  if (ignoreCut(indexNConstituents_) ||
410  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
411  passCut(ret, indexNConstituents_);
412  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
413  passCut(ret, indexNEF_);
414  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
415  passCut(ret, indexNHF_);
416  if (quality_ == TIGHTLEPVETO) {
417  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
418  passCut(ret, indexMUF_);
419  }
420 
421  // Cuts for 2.7 < |eta| <= 3.0 for WINTER16 scenario
422  if (ignoreCut(indexNHF_EC_) ||
423  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
424  passCut(ret, indexNHF_EC_);
425  if (ignoreCut(indexNEF_EC_) ||
426  (nef > cut(indexNEF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
427  passCut(ret, indexNEF_EC_);
428  if (ignoreCut(indexNNeutrals_EC_) ||
429  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
430  passCut(ret, indexNNeutrals_EC_);
431 
432  // Cuts for |eta| > 3.0 for WINTER16 scenario
433  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
434  passCut(ret, indexNEF_FW_);
435  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
436  passCut(ret, indexNNeutrals_FW_);
437  } else if (version_ == WINTER17) {
438  // Cuts for |eta| <= 2.7 for WINTER17 scenario
439  if (ignoreCut(indexNConstituents_) ||
440  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
441  passCut(ret, indexNConstituents_);
442  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
443  passCut(ret, indexNEF_);
444  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
445  passCut(ret, indexNHF_);
446  if (quality_ == TIGHTLEPVETO) {
447  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
448  passCut(ret, indexMUF_);
449  }
450 
451  // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario
452 
453  if (ignoreCut(indexNEF_EC_L_) ||
454  (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
455  passCut(ret, indexNEF_EC_L_);
456  if (ignoreCut(indexNEF_EC_U_) ||
457  (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
458  passCut(ret, indexNEF_EC_U_);
459  if (ignoreCut(indexNNeutrals_EC_) ||
460  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
461  passCut(ret, indexNNeutrals_EC_);
462 
463  // Cuts for |eta| > 3.0 for WINTER17 scenario
464  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
465  passCut(ret, indexNHF_FW_);
466  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
467  passCut(ret, indexNEF_FW_);
468  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
469  passCut(ret, indexNNeutrals_FW_);
470 
471  } else if (version_ == WINTER17PUPPI) {
472  // Cuts for |eta| <= 2.7 for WINTER17 scenario
473  if (ignoreCut(indexNConstituents_) ||
474  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
475  passCut(ret, indexNConstituents_);
476  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
477  passCut(ret, indexNEF_);
478  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
479  passCut(ret, indexNHF_);
480  if (quality_ == TIGHTLEPVETO) {
481  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
482  passCut(ret, indexMUF_);
483  }
484 
485  // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario
486 
487  if (ignoreCut(indexNHF_EC_) ||
488  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
489  passCut(ret, indexNHF_EC_);
490 
491  // Cuts for |eta| > 3.0 for WINTER17 scenario
492  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
493  passCut(ret, indexNHF_FW_);
494  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
495  passCut(ret, indexNEF_FW_);
496  if (ignoreCut(indexNNeutrals_FW_L_) ||
497  (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
498  passCut(ret, indexNNeutrals_FW_L_);
499  if (ignoreCut(indexNNeutrals_FW_U_) ||
500  (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
501  passCut(ret, indexNNeutrals_FW_U_);
502  } else if (version_ == SUMMER18) {
503  // Cuts for |eta| <= 2.6 for SUMMER18 scenario
504  if (ignoreCut(indexNConstituents_) ||
505  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
506  passCut(ret, indexNConstituents_);
507  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
508  passCut(ret, indexNEF_);
509  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
510  passCut(ret, indexNHF_);
511  if (quality_ == TIGHTLEPVETO) {
512  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
513  passCut(ret, indexMUF_);
514  }
515 
516  // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18 scenario
517  if (ignoreCut(indexNHF_TR_) ||
518  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
519  passCut(ret, indexNHF_TR_);
520  if (ignoreCut(indexNEF_TR_) ||
521  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
522  passCut(ret, indexNEF_TR_);
523  if (ignoreCut(indexNCH_TR_) ||
524  (nch > cut(indexNCH_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
525  passCut(ret, indexNCH_TR_);
526  if (quality_ == TIGHTLEPVETO) {
527  if (ignoreCut(indexMUF_TR_) ||
528  (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
529  passCut(ret, indexMUF_TR_);
530  if (ignoreCut(indexCEF_TR_) ||
531  (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
532  passCut(ret, indexCEF_TR_);
533  }
534 
535  // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18 scenario
536  if (ignoreCut(indexNEF_EC_L_) ||
537  (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
538  passCut(ret, indexNEF_EC_L_);
539  if (ignoreCut(indexNEF_EC_U_) ||
540  (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
541  passCut(ret, indexNEF_EC_U_);
542  if (ignoreCut(indexNNeutrals_EC_) ||
543  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
544  passCut(ret, indexNNeutrals_EC_);
545 
546  // Cuts for |eta| > 3.0 for SUMMER18 scenario
547  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
548  passCut(ret, indexNHF_FW_);
549  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
550  passCut(ret, indexNEF_FW_);
551  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
552  passCut(ret, indexNNeutrals_FW_);
553  }
554 
555  else if (version_ == SUMMER18PUPPI) {
556  // Cuts for |eta| <= 2.6 for SUMMER18PUPPI scenario
557  if (ignoreCut(indexNConstituents_) ||
558  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
559  passCut(ret, indexNConstituents_);
560  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
561  passCut(ret, indexNEF_);
562  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
563  passCut(ret, indexNHF_);
564  if (quality_ == TIGHTLEPVETO) {
565  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
566  passCut(ret, indexMUF_);
567  }
568 
569  // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18PUPPI scenario
570  if (ignoreCut(indexNHF_TR_) ||
571  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
572  passCut(ret, indexNHF_TR_);
573  if (ignoreCut(indexNEF_TR_) ||
574  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
575  passCut(ret, indexNEF_TR_);
576  if (quality_ == TIGHTLEPVETO) {
577  if (ignoreCut(indexMUF_TR_) ||
578  (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
579  passCut(ret, indexMUF_TR_);
580  if (ignoreCut(indexCEF_TR_) ||
581  (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
582  passCut(ret, indexCEF_TR_);
583  }
584 
585  // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18PUPPI scenario
586  if (ignoreCut(indexNHF_EC_) ||
587  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
588  passCut(ret, indexNHF_EC_);
589 
590  // Cuts for |eta| > 3.0 for SUMMER18PUPPI scenario
591  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
592  passCut(ret, indexNHF_FW_);
593  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
594  passCut(ret, indexNEF_FW_);
595  if (ignoreCut(indexNNeutrals_FW_L_) ||
596  (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
597  passCut(ret, indexNNeutrals_FW_L_);
598  if (ignoreCut(indexNNeutrals_FW_U_) ||
599  (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
600  passCut(ret, indexNNeutrals_FW_U_);
601  }
602 
603  //std::cout << "<PFJetIDSelectionFunctor::firstDataCuts>:" << std::endl;
604  //std::cout << " jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << std::endl;
605  //ret.print(std::cout);
606  setIgnored(ret);
607  return (bool)ret;
608  }
609 
610 private: // member variables
611  void initCuts() {
612  push_back("CHF");
613  push_back("NHF");
614  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI) ||
615  quality_ != TIGHT)
616  push_back("CEF");
617  push_back("NEF");
618  push_back("NCH");
619  push_back("nConstituents");
620  if (version_ == RUNIISTARTUP) {
621  push_back("NEF_FW");
622  push_back("nNeutrals_FW");
623  }
624  if (version_ == WINTER16) {
625  push_back("NHF_EC");
626  push_back("NEF_EC");
627  push_back("nNeutrals_EC");
628  push_back("NEF_FW");
629  push_back("nNeutrals_FW");
630  if (quality_ == TIGHTLEPVETO)
631  push_back("MUF");
632  }
633  if (version_ == WINTER17) {
634  push_back("NEF_EC_L");
635  push_back("NEF_EC_U");
636  push_back("nNeutrals_EC");
637  push_back("NEF_FW");
638  push_back("NHF_FW");
639  push_back("nNeutrals_FW");
640  if (quality_ == TIGHTLEPVETO)
641  push_back("MUF");
642  }
643  if (version_ == WINTER17PUPPI) {
644  push_back("NHF_EC");
645  push_back("NEF_FW");
646  push_back("NHF_FW");
647  push_back("nNeutrals_FW_L");
648  push_back("nNeutrals_FW_U");
649  if (quality_ == TIGHTLEPVETO)
650  push_back("MUF");
651  }
652  if (version_ == SUMMER18) {
653  push_back("NHF_TR");
654  push_back("NEF_TR");
655  push_back("NCH_TR");
656  push_back("NEF_EC_L");
657  push_back("NEF_EC_U");
658  push_back("nNeutrals_EC");
659  push_back("NEF_FW");
660  push_back("NHF_FW");
661  push_back("nNeutrals_FW");
662 
663  if (quality_ == TIGHTLEPVETO) {
664  push_back("MUF");
665  push_back("MUF_TR");
666  push_back("CEF_TR");
667  }
668  }
669  if (version_ == SUMMER18PUPPI) {
670  push_back("NHF_TR");
671  push_back("NEF_TR");
672  push_back("NHF_EC");
673  push_back("NEF_FW");
674  push_back("NHF_FW");
675  push_back("nNeutrals_FW_L");
676  push_back("nNeutrals_FW_U");
677 
678  if (quality_ == TIGHTLEPVETO) {
679  push_back("MUF");
680  push_back("MUF_TR");
681  push_back("CEF_TR");
682  }
683  }
684 
685  if ((version_ == WINTER17 || version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI) &&
686  quality_ == LOOSE) {
687  edm::LogWarning("BadJetIDVersion")
688  << "The LOOSE operating point is only supported for the WINTER16 JetID version -- defaulting to TIGHT";
689  quality_ = TIGHT;
690  }
691 
692  // Set some default cuts for LOOSE, TIGHT
693  if (quality_ == LOOSE) {
694  set("CHF", 0.0);
695  set("NHF", 0.99);
696  set("CEF", 0.99);
697  set("NEF", 0.99);
698  set("NCH", 0);
699  set("nConstituents", 1);
700  if (version_ == RUNIISTARTUP) {
701  set("NEF_FW", 0.90);
702  set("nNeutrals_FW", 10);
703  } else if (version_ == WINTER16) {
704  set("NHF_EC", 0.98);
705  set("NEF_EC", 0.01);
706  set("nNeutrals_EC", 2);
707  set("NEF_FW", 0.90);
708  set("nNeutrals_FW", 10);
709  }
710  } else if (quality_ == TIGHT) {
711  set("CHF", 0.0);
712  set("NHF", 0.9);
713  if (version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI)
714  set("CEF", 0.99);
715  set("NEF", 0.9);
716  set("NCH", 0);
717  set("nConstituents", 1);
718  if (version_ == RUNIISTARTUP) {
719  set("NEF_FW", 0.90);
720  set("nNeutrals_FW", 10);
721  } else if (version_ == WINTER16) {
722  set("NHF_EC", 0.98);
723  set("NEF_EC", 0.01);
724  set("nNeutrals_EC", 2);
725  set("NEF_FW", 0.90);
726  set("nNeutrals_FW", 10);
727  } else if (version_ == WINTER17) {
728  set("NEF_EC_L", 0.02);
729  set("NEF_EC_U", 0.99);
730  set("nNeutrals_EC", 2);
731  set("NHF_FW", 0.02);
732  set("NEF_FW", 0.90);
733  set("nNeutrals_FW", 10);
734  } else if (version_ == WINTER17PUPPI) {
735  set("NHF_EC", 0.99);
736  set("NHF_FW", 0.02);
737  set("NEF_FW", 0.90);
738  set("nNeutrals_FW_L", 2);
739  set("nNeutrals_FW_U", 15);
740  } else if (version_ == SUMMER18) {
741  set("NHF_TR", 0.9);
742  set("NEF_TR", 0.99);
743  set("NCH_TR", 0);
744  set("NEF_EC_L", 0.02);
745  set("NEF_EC_U", 0.99);
746  set("nNeutrals_EC", 2);
747  set("NHF_FW", 0.2);
748  set("NEF_FW", 0.90);
749  set("nNeutrals_FW", 10);
750  } else if (version_ == SUMMER18PUPPI) {
751  set("NHF_TR", 0.9);
752  set("NEF_TR", 0.99);
753  set("NHF_EC", 0.99);
754  set("NHF_FW", 0.02);
755  set("NEF_FW", 0.90);
756  set("nNeutrals_FW_L", 2);
757  set("nNeutrals_FW_U", 15);
758  }
759  } else if (quality_ == TIGHTLEPVETO) {
760  set("CHF", 0.0);
761  set("NHF", 0.9);
762  set("NEF", 0.9);
763  set("NCH", 0);
764  set("nConstituents", 1);
765  if (version_ == WINTER17) {
766  set("CEF", 0.8);
767  set("NEF_EC_L", 0.02);
768  set("NEF_EC_U", 0.99);
769  set("nNeutrals_EC", 2);
770  set("NHF_FW", 0.02);
771  set("NEF_FW", 0.90);
772  set("nNeutrals_FW", 10);
773  set("MUF", 0.8);
774  } else if (version_ == WINTER17PUPPI) {
775  set("CEF", 0.8);
776  set("NHF_EC", 0.99);
777  set("NHF_FW", 0.02);
778  set("NEF_FW", 0.90);
779  set("nNeutrals_FW_L", 2);
780  set("nNeutrals_FW_U", 15);
781  set("MUF", 0.8);
782  } else if (version_ == WINTER16) {
783  set("CEF", 0.9);
784  set("NEF_EC", 0.01);
785  set("NHF_EC", 0.98);
786  set("nNeutrals_EC", 2);
787  set("nNeutrals_FW", 10);
788  set("NEF_FW", 0.90);
789  set("MUF", 0.8);
790  } else if (version_ == WINTER17PUPPI) {
791  set("CEF", 0.8);
792  set("NHF_EC", 0.99);
793  set("NHF_FW", 0.02);
794  set("NEF_FW", 0.90);
795  set("nNeutrals_FW_L", 2);
796  set("nNeutrals_FW_U", 15);
797  set("MUF", 0.8);
798  } else if (version_ == WINTER16) {
799  set("CEF", 0.9);
800  set("NEF_EC", 0.01);
801  set("NHF_EC", 0.98);
802  set("nNeutrals_EC", 2);
803  set("nNeutrals_FW", 10);
804  set("NEF_FW", 0.90);
805  set("MUF", 0.8);
806  } else if (version_ == SUMMER18) {
807  set("CEF", 0.8);
808  set("MUF", 0.8);
809  set("NHF_TR", 0.9);
810  set("NEF_TR", 0.99);
811  set("MUF_TR", 0.8);
812  set("NCH_TR", 0);
813  set("CEF_TR", 0.8);
814  set("NEF_EC_L", 0.02);
815  set("NEF_EC_U", 0.99);
816  set("nNeutrals_EC", 2);
817  set("NHF_FW", 0.2);
818  set("NEF_FW", 0.90);
819  set("nNeutrals_FW", 10);
820  } else if (version_ == SUMMER18PUPPI) {
821  set("CEF", 0.8);
822  set("MUF", 0.8);
823  set("NHF_TR", 0.9);
824  set("NEF_TR", 0.99);
825  set("MUF_TR", 0.8);
826  set("CEF_TR", 0.8);
827  set("NHF_EC", 0.99);
828  set("NHF_FW", 0.02);
829  set("NEF_FW", 0.90);
830  set("nNeutrals_FW_L", 2);
831  set("nNeutrals_FW_U", 15);
832  }
833  }
834  }
835 
836  void initIndex() {
837  indexNConstituents_ = index_type(&bits_, "nConstituents");
838  indexNEF_ = index_type(&bits_, "NEF");
839  indexNHF_ = index_type(&bits_, "NHF");
840  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI) ||
841  quality_ != TIGHT)
842  indexCEF_ = index_type(&bits_, "CEF");
843 
844  indexCHF_ = index_type(&bits_, "CHF");
845  indexNCH_ = index_type(&bits_, "NCH");
846  if (version_ == RUNIISTARTUP) {
847  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
848  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
849  }
850  if (version_ == WINTER16) {
851  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
852  indexNEF_EC_ = index_type(&bits_, "NEF_EC");
853  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
854  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
855  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
856  if (quality_ == TIGHTLEPVETO) {
857  indexMUF_ = index_type(&bits_, "MUF");
858  }
859  }
860  if (version_ == WINTER17) {
861  indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
862  indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
863  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
864  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
865  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
866  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
867  if (quality_ == TIGHTLEPVETO) {
868  indexMUF_ = index_type(&bits_, "MUF");
869  }
870  }
871  if (version_ == WINTER17PUPPI) {
872  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
873  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
874  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
875  indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
876  indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
877  if (quality_ == TIGHTLEPVETO) {
878  indexMUF_ = index_type(&bits_, "MUF");
879  }
880  }
881  if (version_ == SUMMER18) {
882  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
883  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
884  indexNCH_TR_ = index_type(&bits_, "NCH_TR");
885  indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
886  indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
887  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
888  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
889  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
890  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
891  if (quality_ == TIGHTLEPVETO) {
892  indexMUF_ = index_type(&bits_, "MUF");
893  indexMUF_TR_ = index_type(&bits_, "MUF_TR");
894  indexCEF_TR_ = index_type(&bits_, "CEF_TR");
895  }
896  }
897  if (version_ == SUMMER18PUPPI) {
898  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
899  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
900  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
901  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
902  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
903  indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
904  indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
905  if (quality_ == TIGHTLEPVETO) {
906  indexMUF_ = index_type(&bits_, "MUF");
907  indexMUF_TR_ = index_type(&bits_, "MUF_TR");
908  indexCEF_TR_ = index_type(&bits_, "CEF_TR");
909  }
910  }
911  retInternal_ = getBitTemplate();
912  }
913 
914  Version_t version_;
915  Quality_t quality_;
916 
917  index_type indexNConstituents_;
918  index_type indexNEF_;
919  index_type indexMUF_;
920  index_type indexNHF_;
921  index_type indexCEF_;
922  index_type indexCHF_;
923  index_type indexNCH_;
924 
925  index_type indexNHF_TR_;
926  index_type indexNEF_TR_;
927  index_type indexNCH_TR_;
928  index_type indexMUF_TR_;
929  index_type indexCEF_TR_;
930 
931  index_type indexNHF_FW_;
932  index_type indexNEF_FW_;
933  index_type indexNNeutrals_FW_;
934  index_type indexNNeutrals_FW_L_;
935  index_type indexNNeutrals_FW_U_;
936 
937  index_type indexNHF_EC_;
938  index_type indexNEF_EC_;
939  index_type indexNEF_EC_L_;
940  index_type indexNEF_EC_U_;
941  index_type indexNNeutrals_EC_;
942 };
943 
944 #endif
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:355
PFJetIDSelectionFunctor::Version_t
Version_t
Definition: PFJetIDSelectionFunctor.h:27
reco::PFJet::muonEnergy
float muonEnergy() const
muonEnergy
Definition: PFJet.h:111
PFJetIDSelectionFunctor::FIRSTDATA
Definition: PFJetIDSelectionFunctor.h:27
Selector< pat::Jet >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:181
Selector
Functor that operates on <T>
Definition: Selector.h:22
Selector< pat::Jet >::bits_
pat::strbitset bits_
the bitset indexed by strings
Definition: Selector.h:241
reco::Jet
Base class for all types of Jets.
Definition: Jet.h:20
MessageLogger.h
PFJetIDSelectionFunctor::indexNEF_EC_L_
index_type indexNEF_EC_L_
Definition: PFJetIDSelectionFunctor.h:939
Selector< pat::Jet >::index_type
pat::strbitset::index_type index_type
Definition: Selector.h:25
PFJetIDSelectionFunctor::indexNNeutrals_EC_
index_type indexNNeutrals_EC_
Definition: PFJetIDSelectionFunctor.h:941
PFJetIDSelectionFunctor::firstDataCuts
bool firstDataCuts(reco::Jet const &jet, pat::strbitset &ret, Version_t version_)
Definition: PFJetIDSelectionFunctor.h:246
CalibrationSummaryClient_cfi.params
params
Definition: CalibrationSummaryClient_cfi.py:14
PFJetIDSelectionFunctor::indexNEF_
index_type indexNEF_
Definition: PFJetIDSelectionFunctor.h:918
PFJetIDSelectionFunctor::N_QUALITY
Definition: PFJetIDSelectionFunctor.h:28
pat::strbitset::set
strbitset & set(bool val=true)
set method of all bits
Definition: strbitset.h:126
Selector< pat::Jet >::retInternal_
pat::strbitset retInternal_
internal ret if users don't care about return bits
Definition: Selector.h:242
Selector< pat::Jet >::ignoreCut
bool ignoreCut(std::string const &s) const
ignore the cut at index "s"
Definition: Selector.h:127
PFJetIDSelectionFunctor::operator()
bool operator()(const reco::PFJet &jet, pat::strbitset &ret)
Definition: PFJetIDSelectionFunctor.h:227
pat::Jet::neutralHadronEnergyFraction
float neutralHadronEnergyFraction() const
neutralHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:404
pat::strbitset::index_type
Definition: strbitset.h:25
PFJetIDSelectionFunctor::indexNConstituents_
index_type indexNConstituents_
Definition: PFJetIDSelectionFunctor.h:917
reco::candidate::const_iterator
Definition: const_iterator.h:14
PFJetIDSelectionFunctor::initIndex
void initIndex()
Definition: PFJetIDSelectionFunctor.h:836
cms::cuda::assert
assert(be >=bs)
PFJetIDSelectionFunctor::PFJetIDSelectionFunctor
PFJetIDSelectionFunctor(edm::ParameterSet const &params, edm::ConsumesCollector &iC)
Definition: PFJetIDSelectionFunctor.h:33
PFJetIDSelectionFunctor::indexNHF_FW_
index_type indexNHF_FW_
Definition: PFJetIDSelectionFunctor.h:931
PFJetIDSelectionFunctor::WINTER16
Definition: PFJetIDSelectionFunctor.h:27
PFJetIDSelectionFunctor::indexNCH_
index_type indexNCH_
Definition: PFJetIDSelectionFunctor.h:923
PFJetIDSelectionFunctor::initCuts
void initCuts()
Definition: PFJetIDSelectionFunctor.h:611
PFJetIDSelectionFunctor
PF Jet selector for pat::Jets.
Definition: PFJetIDSelectionFunctor.h:25
Utilities.operator
operator
Definition: Utilities.py:24
PFJetIDSelectionFunctor::PFJetIDSelectionFunctor
PFJetIDSelectionFunctor(edm::ParameterSet const &params)
Definition: PFJetIDSelectionFunctor.h:37
PFJetIDSelectionFunctor::RUNIISTARTUP
Definition: PFJetIDSelectionFunctor.h:27
reco::PFJet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: PFJet.h:95
PFJetIDSelectionFunctor::indexNCH_TR_
index_type indexNCH_TR_
Definition: PFJetIDSelectionFunctor.h:927
reco::BasicJet
Jets made from CaloTowers.
Definition: BasicJet.h:19
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
reco::PFJet::HFEMEnergy
float HFEMEnergy() const
HFEMEnergy.
Definition: PFJet.h:119
PFJetIDSelectionFunctor::PFJetIDSelectionFunctor
PFJetIDSelectionFunctor(Version_t version, Quality_t quality)
Definition: PFJetIDSelectionFunctor.h:202
pat::Jet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: Jet.h:696
PFJetIDSelectionFunctor::indexNHF_TR_
index_type indexNHF_TR_
Definition: PFJetIDSelectionFunctor.h:925
Selector< pat::Jet >::push_back
virtual void push_back(std::string const &s)
This is the registration of an individual cut string.
Definition: Selector.h:42
reco::PFJet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: PFJet.h:152
pat::Jet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: Jet.h:726
PFJetIDSelectionFunctor::WINTER17PUPPI
Definition: PFJetIDSelectionFunctor.h:27
PFJetIDSelectionFunctor::version_
Version_t version_
Definition: PFJetIDSelectionFunctor.h:914
reco::PFJet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: PFJet.h:139
PFJetIDSelectionFunctor::indexNHF_
index_type indexNHF_
Definition: PFJetIDSelectionFunctor.h:920
PFJetIDSelectionFunctor::SUMMER18PUPPI
Definition: PFJetIDSelectionFunctor.h:27
PFJetIDSelectionFunctor::indexMUF_TR_
index_type indexMUF_TR_
Definition: PFJetIDSelectionFunctor.h:928
PFJetIDSelectionFunctor::indexNNeutrals_FW_
index_type indexNNeutrals_FW_
Definition: PFJetIDSelectionFunctor.h:933
pat::Jet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: Jet.h:746
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
pat::Jet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: Jet.h:706
PFJetIDSelectionFunctor::indexNEF_EC_
index_type indexNEF_EC_
Definition: PFJetIDSelectionFunctor.h:938
edm::LogWarning
Definition: MessageLogger.h:141
PFJetIDSelectionFunctor::operator()
bool operator()(const reco::PFJet &jet)
Definition: PFJetIDSelectionFunctor.h:236
reco::PFJet::photonEnergy
float photonEnergy() const
photonEnergy
Definition: PFJet.h:103
Selector< pat::Jet >::getBitTemplate
pat::strbitset getBitTemplate() const
Get an empty bitset with the proper names.
Definition: Selector.h:168
pat::Jet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: Jet.h:716
PFJetIDSelectionFunctor::N_VERSIONS
Definition: PFJetIDSelectionFunctor.h:27
edm::ParameterSet
Definition: ParameterSet.h:36
PFJetIDSelectionFunctor::Quality_t
Quality_t
Definition: PFJetIDSelectionFunctor.h:28
reco::Candidate::end
const_iterator end() const
last daughter const_iterator
Definition: Candidate.h:145
pat::Jet::neutralEmEnergyFraction
float neutralEmEnergyFraction() const
neutralEmEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:412
Selector< pat::Jet >::passCut
void passCut(pat::strbitset &ret, std::string const &s)
Passing cuts.
Definition: Selector.h:142
pat::Jet::isBasicJet
bool isBasicJet() const
check to see if the jet is no more than a reco::BasicJet
Definition: Jet.h:277
pat::Jet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: Jet.h:466
PFJetIDSelectionFunctor::indexNEF_EC_U_
index_type indexNEF_EC_U_
Definition: PFJetIDSelectionFunctor.h:940
PFJetIDSelectionFunctor::operator()
bool operator()(const pat::Jet &jet, pat::strbitset &ret) override
This provides the interface for base classes to select objects.
Definition: PFJetIDSelectionFunctor.h:210
PFJetIDSelectionFunctor::indexNEF_TR_
index_type indexNEF_TR_
Definition: PFJetIDSelectionFunctor.h:926
PFJetIDSelectionFunctor::indexNNeutrals_FW_L_
index_type indexNNeutrals_FW_L_
Definition: PFJetIDSelectionFunctor.h:934
Selector< pat::Jet >::setIgnoredCuts
void setIgnoredCuts(std::vector< std::string > const &bitsToIgnore)
set the bits to ignore from a vector
Definition: Selector.h:131
PFJetIDSelectionFunctor::indexMUF_
index_type indexMUF_
Definition: PFJetIDSelectionFunctor.h:919
PFJetIDSelectionFunctor::indexCHF_
index_type indexCHF_
Definition: PFJetIDSelectionFunctor.h:922
Jet.h
pat::Jet::isPFJet
bool isPFJet() const
check to see if the jet is a reco::PFJet
Definition: Jet.h:275
pat::Jet::chargedEmEnergyFraction
float chargedEmEnergyFraction() const
chargedEmEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:408
PFJetIDSelectionFunctor::indexNEF_FW_
index_type indexNEF_FW_
Definition: PFJetIDSelectionFunctor.h:932
PFJetIDSelectionFunctor::TIGHT
Definition: PFJetIDSelectionFunctor.h:28
pat::strbitset
Definition: strbitset.h:23
pat::Jet::muonEnergy
float muonEnergy() const
muonEnergy
Definition: Jet.h:430
PFJetIDSelectionFunctor::indexCEF_TR_
index_type indexCEF_TR_
Definition: PFJetIDSelectionFunctor.h:929
pat::Jet::chargedHadronEnergyFraction
float chargedHadronEnergyFraction() const
chargedHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:400
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
Selector< pat::Jet >::cut
int cut(index_type const &i, int val) const
Access the int cut values at index "s".
Definition: Selector.h:158
reco::PFJet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: PFJet.h:99
metsig::jet
Definition: SignAlgoResolutions.h:47
pat::Jet::muonEnergyFraction
float muonEnergyFraction() const
muonEnergyFraction (relative to corrected jet energy)
Definition: Jet.h:432
reco::PFJet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: PFJet.h:154
PFJetIDSelectionFunctor::PFJetIDSelectionFunctor
PFJetIDSelectionFunctor()
Definition: PFJetIDSelectionFunctor.h:30
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20
PFJetIDSelectionFunctor::TIGHTLEPVETO
Definition: PFJetIDSelectionFunctor.h:28
reco::PFJet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: PFJet.h:147
PFJetIDSelectionFunctor::WINTER17
Definition: PFJetIDSelectionFunctor.h:27
reco::LeafCandidate::energy
double energy() const final
energy
Definition: LeafCandidate.h:125
Selector< pat::Jet >::set
void set(std::string const &s, bool val=true)
Set a given selection cut, on or off.
Definition: Selector.h:93
PFJetIDSelectionFunctor::SUMMER18
Definition: PFJetIDSelectionFunctor.h:27
ConsumesCollector.h
PFJetIDSelectionFunctor::indexNNeutrals_FW_U_
index_type indexNNeutrals_FW_U_
Definition: PFJetIDSelectionFunctor.h:935
PFJetIDSelectionFunctor::quality_
Quality_t quality_
Definition: PFJetIDSelectionFunctor.h:915
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
BeamSplash_cfg.version
version
Definition: BeamSplash_cfg.py:45
PFJetIDSelectionFunctor::indexNHF_EC_
index_type indexNHF_EC_
Definition: PFJetIDSelectionFunctor.h:937
reco::Candidate::begin
const_iterator begin() const
first daughter const_iterator
Definition: Candidate.h:143
reco::PFJet::electronEnergy
float electronEnergy() const
electronEnergy
Definition: PFJet.h:107
Selector.h
PFJetIDSelectionFunctor::indexCEF_
index_type indexCEF_
Definition: PFJetIDSelectionFunctor.h:921
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
PFJetIDSelectionFunctor::LOOSE
Definition: PFJetIDSelectionFunctor.h:28
Generated for CMSSW Reference Manual by doxygen 1.8.16