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