CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
PFJetIDSelectionFunctor Class Reference

PF Jet selector for pat::Jets. More...

#include "PhysicsTools/SelectorUtils/interface/PFJetIDSelectionFunctor.h"

Inheritance diagram for PFJetIDSelectionFunctor:
Selector< pat::Jet >

Public Types

enum  Quality_t { LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY }
 
enum  Version_t {
  FIRSTDATA, RUNIISTARTUP, WINTER16, WINTER17,
  WINTER17PUPPI, SUMMER18, SUMMER18PUPPI, RUN2UL16CHS,
  RUN2UL16PUPPI, RUN3CHSrunsBCDEprompt, RUN3PUPPIrunsBCDEprompt, RUN3CHSruns2022FGruns2023CD,
  RUN3PUPPIruns2022FGruns2023CD, RUN2ULCHS, RUN2ULPUPPI, N_VERSIONS
}
 
- Public Types inherited from Selector< pat::Jet >
typedef std::pair< index_type, size_t > cut_flow_item
 
typedef std::vector< cut_flow_item > cut_flow_map
 
typedef pat::Jet data_type
 
typedef std::map< index_type, double > double_map
 
typedef pat::strbitset::index_type index_type
 
typedef std::map< index_type, int > int_map
 

Public Member Functions

bool firstDataCuts (reco::Jet const &jet, pat::strbitset &ret, Version_t version_)
 
bool operator() (const pat::Jet &jet, pat::strbitset &ret) override
 This provides the interface for base classes to select objects. More...
 
bool operator() (const reco::PFJet &jet, pat::strbitset &ret)
 
bool operator() (const reco::PFJet &jet)
 
 PFJetIDSelectionFunctor ()
 
 PFJetIDSelectionFunctor (edm::ParameterSet const &params, edm::ConsumesCollector &iC)
 
 PFJetIDSelectionFunctor (edm::ParameterSet const &params)
 
 PFJetIDSelectionFunctor (Version_t version, Quality_t quality)
 
- Public Member Functions inherited from Selector< pat::Jet >
void clear (std::string const &s)
 Turn off a given selection cut. More...
 
void clear (index_type const &i)
 
bool considerCut (std::string const &s) const
 consider the cut at index "s" More...
 
bool considerCut (index_type const &i) const
 
int cut (index_type const &i, int val) const
 Access the int cut values at index "s". More...
 
double cut (index_type const &i, double val) const
 Access the double cut values at index "s". More...
 
int cut (std::string s, int val) const
 Access the int cut values at index "s". More...
 
double cut (std::string s, double val) const
 Access the double cut values at index "s". More...
 
pat::strbitset getBitTemplate () const
 Get an empty bitset with the proper names. More...
 
double getPasses (std::string const &s) const
 Return the number of passing cases. More...
 
double getPasses (index_type const &i) const
 
bool ignoreCut (std::string const &s) const
 ignore the cut at index "s" More...
 
bool ignoreCut (index_type const &i) const
 
virtual bool operator() (pat::Jet const &t)
 This provides an alternative signature without the second ret. More...
 
virtual bool operator() (pat::Jet const &t, edm::EventBase const &e, pat::strbitset &ret)
 This provides an alternative signature that includes extra information. More...
 
virtual bool operator() (pat::Jet const &t, edm::EventBase const &e)
 This provides an alternative signature that includes extra information. More...
 
bool operator[] (std::string const &s) const
 
bool operator[] (index_type const &i) const
 
void passCut (pat::strbitset &ret, std::string const &s)
 Passing cuts. More...
 
void passCut (pat::strbitset &ret, index_type const &i)
 
void print (std::ostream &out) const
 Print the cut flow. More...
 
void printActiveCuts (std::ostream &out) const
 Print the cuts being considered. More...
 
virtual void push_back (std::string const &s)
 This is the registration of an individual cut string. More...
 
virtual void push_back (std::string const &s, int cut)
 This is the registration of an individual cut string, with an int cut value. More...
 
virtual void push_back (std::string const &s, double cut)
 This is the registration of an individual cut string, with a double cut value. More...
 
 Selector ()
 Constructor clears the bits. More...
 
void set (std::string const &s, bool val=true)
 Set a given selection cut, on or off. More...
 
void set (index_type const &i, bool val=true)
 
void set (std::string const &s, int cut, bool val=true)
 Set a given selection cut, on or off, and reset int cut value. More...
 
void set (index_type const &i, int cut, bool val=true)
 
void set (std::string const &s, double cut, bool val=true)
 Set a given selection cut, on or off, and reset int cut value. More...
 
void set (index_type const &i, double cut, bool val=true)
 
void setIgnored (pat::strbitset &ret)
 set ignored bits More...
 
void setIgnoredCuts (std::vector< std::string > const &bitsToIgnore)
 set the bits to ignore from a vector More...
 
virtual ~Selector ()
 

Static Public Member Functions

static edm::ParameterSetDescription getDescription ()
 

Private Member Functions

void initCuts ()
 
void initIndex ()
 

Private Attributes

index_type indexCEF_
 
index_type indexCEF_TR_
 
index_type indexCHF_
 
index_type indexMUF_
 
index_type indexMUF_TR_
 
index_type indexNCH_
 
index_type indexNCH_TR_
 
index_type indexNConstituents_
 
index_type indexNEF_
 
index_type indexNEF_EC_
 
index_type indexNEF_EC_L_
 
index_type indexNEF_EC_U_
 
index_type indexNEF_FW_
 
index_type indexNEF_TR_
 
index_type indexNHF_
 
index_type indexNHF_EC_
 
index_type indexNHF_FW_
 
index_type indexNHF_TR_
 
index_type indexNNeutrals_EC_
 
index_type indexNNeutrals_FW_
 
index_type indexNNeutrals_FW_L_
 
index_type indexNNeutrals_FW_U_
 
Quality_t quality_
 
Version_t version_
 

Additional Inherited Members

- Protected Attributes inherited from Selector< pat::Jet >
pat::strbitset bits_
 the bitset indexed by strings More...
 
cut_flow_map cutFlow_
 map of cut flows in "human" order More...
 
double_map doubleCuts_
 the double-value cut map More...
 
int_map intCuts_
 the int-value cut map More...
 
pat::strbitset retInternal_
 internal ret if users don't care about return bits More...
 

Detailed Description

PF Jet selector for pat::Jets.

Selector functor for pat::Jets that implements quality cuts based on studies of noise patterns.

Please see https://twiki.cern.ch/twiki/bin/view/CMS/SWGuidePATSelectors for a general overview of the selectors.

Definition at line 28 of file PFJetIDSelectionFunctor.h.

Member Enumeration Documentation

◆ Quality_t

enum PFJetIDSelectionFunctor::Quality_t
Enumerator
LOOSE 
TIGHT 
TIGHTLEPVETO 
N_QUALITY 

Definition at line 48 of file PFJetIDSelectionFunctor.h.

48 { LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY };

◆ Version_t

enum PFJetIDSelectionFunctor::Version_t
Enumerator
FIRSTDATA 
RUNIISTARTUP 
WINTER16 
WINTER17 
WINTER17PUPPI 
SUMMER18 
SUMMER18PUPPI 
RUN2UL16CHS 
RUN2UL16PUPPI 
RUN3CHSrunsBCDEprompt 
RUN3PUPPIrunsBCDEprompt 
RUN3CHSruns2022FGruns2023CD 
RUN3PUPPIruns2022FGruns2023CD 
RUN2ULCHS 
RUN2ULPUPPI 
N_VERSIONS 

Definition at line 30 of file PFJetIDSelectionFunctor.h.

30  {
31  FIRSTDATA,
32  RUNIISTARTUP,
33  WINTER16,
34  WINTER17,
35  WINTER17PUPPI,
36  SUMMER18,
37  SUMMER18PUPPI,
38  RUN2UL16CHS,
39  RUN2UL16PUPPI,
40  RUN3CHSrunsBCDEprompt,
41  RUN3PUPPIrunsBCDEprompt,
42  RUN3CHSruns2022FGruns2023CD,
43  RUN3PUPPIruns2022FGruns2023CD,
44  RUN2ULCHS,
45  RUN2ULPUPPI,
46  N_VERSIONS
47  };

Constructor & Destructor Documentation

◆ PFJetIDSelectionFunctor() [1/4]

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( )
inline

Definition at line 50 of file PFJetIDSelectionFunctor.h.

50 {}

◆ PFJetIDSelectionFunctor() [2/4]

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( edm::ParameterSet const &  params,
edm::ConsumesCollector &  iC 
)
inline

Definition at line 53 of file PFJetIDSelectionFunctor.h.

54  : PFJetIDSelectionFunctor(params) {}

◆ PFJetIDSelectionFunctor() [3/4]

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( edm::ParameterSet const &  params)
inline

Definition at line 57 of file PFJetIDSelectionFunctor.h.

References Selector< pat::Jet >::bits_, FIRSTDATA, mps_fire::i, initCuts(), initIndex(), B2GTnPMonitor_cfi::item, LOOSE, submitPVValidationJobs::params, quality_, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, Selector< pat::Jet >::setIgnoredCuts(), AlCaHLTBitMon_QueryRunRegistry::string, pat::strbitset::strings(), SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

57  {
58  std::string versionStr = params.getParameter<std::string>("version");
59  std::string qualityStr = params.getParameter<std::string>("quality");
60 
61  if (versionStr == "FIRSTDATA")
62  version_ = FIRSTDATA;
63  else if (versionStr == "RUNIISTARTUP")
64  version_ = RUNIISTARTUP;
65  else if (versionStr == "WINTER16")
66  version_ = WINTER16;
67  else if (versionStr == "WINTER17")
68  version_ = WINTER17;
69  else if (versionStr == "WINTER17PUPPI")
70  version_ = WINTER17PUPPI;
71  else if (versionStr == "SUMMER18")
72  version_ = SUMMER18;
73  else if (versionStr == "SUMMER18PUPPI")
74  version_ = SUMMER18PUPPI;
75  else if (versionStr == "RUN2UL16CHS")
76  version_ = RUN2UL16CHS;
77  else if (versionStr == "RUN2UL16PUPPI")
78  version_ = RUN2UL16PUPPI;
79  else if (versionStr == "RUN2ULCHS")
80  version_ = RUN2ULCHS;
81  else if (versionStr == "RUN2ULPUPPI")
82  version_ = RUN2ULPUPPI;
83  else if (versionStr == "RUN3CHSrunsBCDEprompt")
84  version_ = RUN3CHSrunsBCDEprompt;
85  else if (versionStr == "RUN3PUPPIrunsBCDEprompt")
86  version_ = RUN3PUPPIrunsBCDEprompt;
87  else if (versionStr == "RUN3CHSruns2022FGruns2023CD")
88  version_ = RUN3CHSruns2022FGruns2023CD;
89  else if (versionStr == "RUN3PUPPIruns2022FGruns2023CD")
90  version_ = RUN3PUPPIruns2022FGruns2023CD;
91  else
92  version_ =
93  RUN3PUPPIruns2022FGruns2023CD; //set RUN3PUPPIruns2022FGruns2023CD as default //this is extremely unsafe
94 
95  if (qualityStr == "LOOSE")
96  quality_ = LOOSE;
97  else if (qualityStr == "TIGHT")
98  quality_ = TIGHT;
99  else if (qualityStr == "TIGHTLEPVETO")
100  quality_ = TIGHTLEPVETO;
101  else
102  quality_ = TIGHT; //this is extremely unsafe
103 
104  initCuts();
105 
106  // loop over the std::string in bits_ and check for what was overwritten.
107  const auto strings_set = this->bits_.strings();
108  for (auto i = strings_set.begin(); i != strings_set.end(); ++i) {
109  const std::string &item = *i;
110  if (params.exists(item)) {
111  if (params.existsAs<int>(item))
112  set(item, params.getParameter<int>(item));
113  else
114  set(item, params.getParameter<double>(item));
115  }
116  }
117 
118  if (params.exists("cutsToIgnore"))
119  setIgnoredCuts(params.getParameter<std::vector<std::string>>("cutsToIgnore"));
120 
121  initIndex();
122  }
mps_fire.i
i
Definition: mps_fire.py:429
pat::strbitset::strings
const std::vector< std::string > strings() const
give access to the ordered strings
Definition: strbitset.h:295
B2GTnPMonitor_cfi.item
item
Definition: B2GTnPMonitor_cfi.py:148
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Selector< pat::Jet >::bits_
pat::strbitset bits_
the bitset indexed by strings
Definition: Selector.h:241
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() [4/4]

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( Version_t  version,
Quality_t  quality 
)
inline

Definition at line 124 of file PFJetIDSelectionFunctor.h.

References initCuts(), and initIndex().

124  : version_(version), quality_(quality) {
125  initCuts();
126  initIndex();
127  }
quality
string quality
Definition: beamSpotDipStandalone.cc:53
BeamSplash_cfg.version
version
Definition: BeamSplash_cfg.py:45

Member Function Documentation

◆ firstDataCuts()

bool PFJetIDSelectionFunctor::firstDataCuts ( reco::Jet const &  jet,
pat::strbitset &  ret,
Version_t  version_ 
)
inline

Definition at line 255 of file PFJetIDSelectionFunctor.h.

References funct::abs(), cms::cuda::assert(), reco::Candidate::begin(), reco::PFJet::chargedEmEnergy(), pat::Jet::chargedEmEnergy(), pat::Jet::chargedEmEnergyFraction(), reco::PFJet::chargedHadronEnergy(), pat::Jet::chargedHadronEnergy(), pat::Jet::chargedHadronEnergyFraction(), reco::PFJet::chargedMultiplicity(), pat::Jet::chargedMultiplicity(), Selector< pat::Jet >::cut(), MillePedeFileConverter_cfg::e, reco::PFJet::electronEnergy(), reco::Candidate::end(), reco::LeafCandidate::energy(), FIRSTDATA, reco::PFJet::HFEMEnergy(), Selector< pat::Jet >::ignoreCut(), indexCEF_, indexCEF_TR_, indexCHF_, indexMUF_, indexMUF_TR_, indexNCH_, indexNCH_TR_, indexNConstituents_, indexNEF_, indexNEF_EC_, indexNEF_EC_L_, indexNEF_EC_U_, indexNEF_FW_, indexNEF_TR_, indexNHF_, indexNHF_EC_, indexNHF_FW_, indexNHF_TR_, indexNNeutrals_EC_, indexNNeutrals_FW_, indexNNeutrals_FW_L_, indexNNeutrals_FW_U_, pat::Jet::isBasicJet(), pat::Jet::isPFJet(), metsig::jet, reco::PFJet::muonEnergy(), pat::Jet::muonEnergy(), pat::Jet::muonEnergyFraction(), reco::PFJet::neutralEmEnergy(), pat::Jet::neutralEmEnergy(), pat::Jet::neutralEmEnergyFraction(), reco::PFJet::neutralHadronEnergy(), pat::Jet::neutralHadronEnergy(), pat::Jet::neutralHadronEnergyFraction(), reco::PFJet::neutralMultiplicity(), pat::Jet::neutralMultiplicity(), Selector< pat::Jet >::passCut(), reco::PFJet::photonEnergy(), quality_, runTheMatrix::ret, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, Selector< pat::Jet >::setIgnored(), SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by operator()().

255  {
256  ret.set(false);
257 
258  // cache some variables
259  double chf = 0.0;
260  double nhf = 0.0;
261  double cef = 0.0;
262  double nef = 0.0;
263  double muf = 0.0;
264 
265  int nch = 0;
266  int nconstituents = 0;
267  int nneutrals = 0;
268 
269  // Have to do this because pat::Jet inherits from reco::Jet but not reco::PFJet
270  reco::PFJet const *pfJet = dynamic_cast<reco::PFJet const *>(&jet);
271  pat::Jet const *patJet = dynamic_cast<pat::Jet const *>(&jet);
272  reco::BasicJet const *basicJet = dynamic_cast<reco::BasicJet const *>(&jet);
273 
274  if (patJet != nullptr) {
275  if (patJet->isPFJet()) {
276  chf = patJet->chargedHadronEnergyFraction();
277  nhf = patJet->neutralHadronEnergyFraction();
278  cef = patJet->chargedEmEnergyFraction();
279  nef = patJet->neutralEmEnergyFraction();
280  nch = patJet->chargedMultiplicity();
281  muf = patJet->muonEnergyFraction();
282  nconstituents = patJet->neutralMultiplicity() + patJet->chargedMultiplicity();
283  nneutrals = patJet->neutralMultiplicity();
284  }
285  // Handle the special case where this is a composed jet for
286  // subjet analyses
287  else if (patJet->isBasicJet()) {
288  double e_chf = 0.0;
289  double e_nhf = 0.0;
290  double e_cef = 0.0;
291  double e_nef = 0.0;
292  double e_muf = 0.0;
293  nch = 0;
294  nconstituents = 0;
295  nneutrals = 0;
296 
297  for (reco::Jet::const_iterator ibegin = patJet->begin(), iend = patJet->end(), isub = ibegin; isub != iend;
298  ++isub) {
299  reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
300  pat::Jet const *patsub = dynamic_cast<pat::Jet const *>(&*isub);
301  if (patsub) {
302  e_chf += patsub->chargedHadronEnergy();
303  e_nhf += patsub->neutralHadronEnergy();
304  e_cef += patsub->chargedEmEnergy();
305  e_nef += patsub->neutralEmEnergy();
306  e_muf += patsub->muonEnergy();
307  nch += patsub->chargedMultiplicity();
308  nconstituents += patsub->neutralMultiplicity() + patsub->chargedMultiplicity();
309  nneutrals += patsub->neutralMultiplicity();
310  } else if (pfsub) {
311  e_chf += pfsub->chargedHadronEnergy();
312  e_nhf += pfsub->neutralHadronEnergy();
313  e_cef += pfsub->chargedEmEnergy();
314  e_nef += pfsub->neutralEmEnergy();
315  e_muf += pfsub->muonEnergy();
316  nch += pfsub->chargedMultiplicity();
317  nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
318  nneutrals += pfsub->neutralMultiplicity();
319  } else
320  assert(0);
321  }
322  double e = patJet->energy();
323  if (e > 0.000001) {
324  chf = e_chf / e;
325  nhf = e_nhf / e;
326  cef = e_cef / e;
327  nef = e_nef / e;
328  muf = e_muf / e;
329  } else {
330  chf = nhf = cef = nef = muf = 0.0;
331  }
332  }
333  } // end if pat jet
334  else if (pfJet != nullptr) {
335  // CV: need to compute energy fractions in a way that works for corrected as well as for uncorrected PFJets
336  double jetEnergyUncorrected = pfJet->chargedHadronEnergy() + pfJet->neutralHadronEnergy() +
337  pfJet->photonEnergy() + pfJet->electronEnergy() + pfJet->muonEnergy() +
338  pfJet->HFEMEnergy();
339  if (jetEnergyUncorrected > 0.) {
340  chf = pfJet->chargedHadronEnergy() / jetEnergyUncorrected;
341  nhf = pfJet->neutralHadronEnergy() / jetEnergyUncorrected;
342  cef = pfJet->chargedEmEnergy() / jetEnergyUncorrected;
343  nef = pfJet->neutralEmEnergy() / jetEnergyUncorrected;
344  muf = pfJet->muonEnergy() / jetEnergyUncorrected;
345  }
346  nch = pfJet->chargedMultiplicity();
347  nconstituents = pfJet->neutralMultiplicity() + pfJet->chargedMultiplicity();
348  nneutrals = pfJet->neutralMultiplicity();
349  } // end if PF jet
350  // Handle the special case where this is a composed jet for
351  // subjet analyses
352  else if (basicJet != nullptr) {
353  double e_chf = 0.0;
354  double e_nhf = 0.0;
355  double e_cef = 0.0;
356  double e_nef = 0.0;
357  double e_muf = 0.0;
358  nch = 0;
359  nconstituents = 0;
360  for (reco::Jet::const_iterator ibegin = basicJet->begin(), iend = basicJet->end(), isub = ibegin; isub != iend;
361  ++isub) {
362  reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
363  e_chf += pfsub->chargedHadronEnergy();
364  e_nhf += pfsub->neutralHadronEnergy();
365  e_cef += pfsub->chargedEmEnergy();
366  e_nef += pfsub->neutralEmEnergy();
367  e_muf += pfsub->muonEnergy();
368  nch += pfsub->chargedMultiplicity();
369  nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
370  nneutrals += pfsub->neutralMultiplicity();
371  }
372  double e = basicJet->energy();
373  if (e > 0.000001) {
374  chf = e_chf / e;
375  nhf = e_nhf / e;
376  cef = e_cef / e;
377  nef = e_nef / e;
378  muf = e_muf / e;
379  }
380  } // end if basic jet
381 
382  float etaB = 2.4;
383  // Cuts for |eta| < 2.6 for Summer18
384  if (version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI ||
385  version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
386  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD)
387  etaB = 2.6;
388  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
389  version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN3CHSrunsBCDEprompt &&
390  version_ != RUN3PUPPIrunsBCDEprompt && version_ != RUN3CHSruns2022FGruns2023CD &&
391  version_ != RUN3PUPPIruns2022FGruns2023CD && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI) ||
392  quality_ != TIGHT) {
393  if (ignoreCut(indexCEF_) || (cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > etaB))
394  passCut(ret, indexCEF_);
395  }
396  if (ignoreCut(indexCHF_) || (chf > cut(indexCHF_, double()) || std::abs(jet.eta()) > etaB))
397  passCut(ret, indexCHF_);
398  if (ignoreCut(indexNCH_) || (nch > cut(indexNCH_, int()) || std::abs(jet.eta()) > etaB))
399  passCut(ret, indexNCH_);
400  if (version_ == FIRSTDATA) { // Cuts for all eta for FIRSTDATA
401  if (ignoreCut(indexNConstituents_) || (nconstituents > cut(indexNConstituents_, int())))
402  passCut(ret, indexNConstituents_);
403  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double())))
404  passCut(ret, indexNEF_);
405  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double())))
406  passCut(ret, indexNHF_);
407  } else if (version_ == RUNIISTARTUP) {
408  // Cuts for |eta| <= 3.0 for RUNIISTARTUP scenario
409  if (ignoreCut(indexNConstituents_) ||
410  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 3.0))
411  passCut(ret, indexNConstituents_);
412  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 3.0))
413  passCut(ret, indexNEF_);
414  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 3.0))
415  passCut(ret, indexNHF_);
416  // Cuts for |eta| > 3.0 for RUNIISTARTUP scenario
417  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
418  passCut(ret, indexNEF_FW_);
419  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
420  passCut(ret, indexNNeutrals_FW_);
421  } else if (version_ == WINTER16) {
422  // Cuts for |eta| <= 2.7 for WINTER16 scenario
423  if (ignoreCut(indexNConstituents_) ||
424  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
425  passCut(ret, indexNConstituents_);
426  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
427  passCut(ret, indexNEF_);
428  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
429  passCut(ret, indexNHF_);
430  if (quality_ == TIGHTLEPVETO) {
431  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
432  passCut(ret, indexMUF_);
433  }
434 
435  // Cuts for 2.7 < |eta| <= 3.0 for WINTER16 scenario
436  if (ignoreCut(indexNHF_EC_) ||
437  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
438  passCut(ret, indexNHF_EC_);
439  if (ignoreCut(indexNEF_EC_) ||
440  (nef > cut(indexNEF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
441  passCut(ret, indexNEF_EC_);
442  if (ignoreCut(indexNNeutrals_EC_) ||
443  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
444  passCut(ret, indexNNeutrals_EC_);
445 
446  // Cuts for |eta| > 3.0 for WINTER16 scenario
447  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
448  passCut(ret, indexNEF_FW_);
449  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
450  passCut(ret, indexNNeutrals_FW_);
451  } else if (version_ == WINTER17) {
452  // Cuts for |eta| <= 2.7 for WINTER17 scenario
453  if (ignoreCut(indexNConstituents_) ||
454  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
455  passCut(ret, indexNConstituents_);
456  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
457  passCut(ret, indexNEF_);
458  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
459  passCut(ret, indexNHF_);
460  if (quality_ == TIGHTLEPVETO) {
461  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
462  passCut(ret, indexMUF_);
463  }
464 
465  // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario
466 
467  if (ignoreCut(indexNEF_EC_L_) ||
468  (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
469  passCut(ret, indexNEF_EC_L_);
470  if (ignoreCut(indexNEF_EC_U_) ||
471  (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
472  passCut(ret, indexNEF_EC_U_);
473  if (ignoreCut(indexNNeutrals_EC_) ||
474  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
475  passCut(ret, indexNNeutrals_EC_);
476 
477  // Cuts for |eta| > 3.0 for WINTER17 scenario
478  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
479  passCut(ret, indexNHF_FW_);
480  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
481  passCut(ret, indexNEF_FW_);
482  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
483  passCut(ret, indexNNeutrals_FW_);
484 
485  } else if (version_ == WINTER17PUPPI) {
486  // Cuts for |eta| <= 2.7 for WINTER17 scenario
487  if (ignoreCut(indexNConstituents_) ||
488  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
489  passCut(ret, indexNConstituents_);
490  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
491  passCut(ret, indexNEF_);
492  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
493  passCut(ret, indexNHF_);
494  if (quality_ == TIGHTLEPVETO) {
495  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
496  passCut(ret, indexMUF_);
497  }
498 
499  // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario
500 
501  if (ignoreCut(indexNHF_EC_) ||
502  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
503  passCut(ret, indexNHF_EC_);
504 
505  // Cuts for |eta| > 3.0 for WINTER17 scenario
506  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
507  passCut(ret, indexNHF_FW_);
508  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
509  passCut(ret, indexNEF_FW_);
510  if (ignoreCut(indexNNeutrals_FW_L_) ||
511  (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
512  passCut(ret, indexNNeutrals_FW_L_);
513  if (ignoreCut(indexNNeutrals_FW_U_) ||
514  (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
515  passCut(ret, indexNNeutrals_FW_U_);
516 
517  } else if (version_ == RUN2UL16CHS) {
518  // Cuts for |eta| <= 2.4 for RUN2UL16CHS scenario
519  if (ignoreCut(indexNConstituents_) ||
520  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.4))
521  passCut(ret, indexNConstituents_);
522  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.4))
523  passCut(ret, indexNEF_);
524  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.4))
525  passCut(ret, indexNHF_);
526  if (quality_ == TIGHTLEPVETO) {
527  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.4))
528  passCut(ret, indexMUF_);
529  }
530 
531  // Cuts for 2.4 <= |eta| <= 2.7 for RUN2UL16CHS scenario
532  if (ignoreCut(indexNHF_TR_) ||
533  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
534  passCut(ret, indexNHF_TR_);
535  if (ignoreCut(indexNEF_TR_) ||
536  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
537  passCut(ret, indexNEF_TR_);
538 
539  // Cuts for 2.7 < |eta| <= 3.0 for RUN2UL16CHS scenario
540  if (ignoreCut(indexNHF_EC_) ||
541  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
542  passCut(ret, indexNHF_EC_);
543  if (ignoreCut(indexNEF_EC_L_) ||
544  (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
545  passCut(ret, indexNEF_EC_L_);
546  if (ignoreCut(indexNEF_EC_U_) ||
547  (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
548  passCut(ret, indexNEF_EC_U_);
549  if (ignoreCut(indexNNeutrals_EC_) ||
550  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
551  passCut(ret, indexNNeutrals_EC_);
552 
553  // Cuts for |eta| > 3.0 for RUN2UL16CHS scenario
554  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
555  passCut(ret, indexNHF_FW_);
556  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
557  passCut(ret, indexNEF_FW_);
558  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
559  passCut(ret, indexNNeutrals_FW_);
560 
561  } else if (version_ == RUN2UL16PUPPI) {
562  // Cuts for |eta| <= 2.4 for RUN2UL16PUPPI scenario
563  if (ignoreCut(indexNConstituents_) ||
564  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.4))
565  passCut(ret, indexNConstituents_);
566  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.4))
567  passCut(ret, indexNEF_);
568  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.4))
569  passCut(ret, indexNHF_);
570  if (quality_ == TIGHTLEPVETO) {
571  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.4))
572  passCut(ret, indexMUF_);
573  }
574 
575  // Cuts for 2.4 <= |eta| <= 2.7 for RUN2UL16PUPPI scenario
576  if (ignoreCut(indexNHF_TR_) ||
577  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
578  passCut(ret, indexNHF_TR_);
579  if (ignoreCut(indexNEF_TR_) ||
580  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
581  passCut(ret, indexNEF_TR_);
582 
583  // Cuts for 2.7 < |eta| <= 3.0 for RUN2UL16PUPPI scenario
584  if (ignoreCut(indexNNeutrals_EC_) ||
585  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
586  passCut(ret, indexNNeutrals_EC_);
587 
588  // Cuts for |eta| > 3.0 for RUN2UL16PUPPI scenario
589  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
590  passCut(ret, indexNEF_FW_);
591  if (ignoreCut(indexNNeutrals_FW_L_) ||
592  (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
593  passCut(ret, indexNNeutrals_FW_L_);
594  if (ignoreCut(indexNNeutrals_FW_U_) ||
595  (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
596  passCut(ret, indexNNeutrals_FW_U_);
597 
598  } else if ((version_ == SUMMER18) || (version_ == RUN2ULCHS) || (version_ == RUN3CHSrunsBCDEprompt) ||
599  (version_ == RUN3CHSruns2022FGruns2023CD)) {
600  // Cuts for |eta| <= 2.6 for SUMMER18 scenario
601  if (ignoreCut(indexNConstituents_) ||
602  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
603  passCut(ret, indexNConstituents_);
604  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
605  passCut(ret, indexNEF_);
606  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
607  passCut(ret, indexNHF_);
608  if (quality_ == TIGHTLEPVETO) {
609  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
610  passCut(ret, indexMUF_);
611  if (ignoreCut(indexCEF_) || (cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > 2.6)) //edw
612  passCut(ret, indexCEF_);
613  }
614 
615  // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18 scenario
616  if (ignoreCut(indexNHF_TR_) ||
617  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
618  passCut(ret, indexNHF_TR_);
619  if (ignoreCut(indexNEF_TR_) ||
620  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
621  passCut(ret, indexNEF_TR_);
622  if (ignoreCut(indexNCH_TR_) ||
623  (nch > cut(indexNCH_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
624  passCut(ret, indexNCH_TR_);
625  if (quality_ == TIGHTLEPVETO) {
626  if (ignoreCut(indexMUF_TR_) ||
627  (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
628  passCut(ret, indexMUF_TR_);
629  if (ignoreCut(indexCEF_TR_) ||
630  (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
631  passCut(ret, indexCEF_TR_);
632  }
633 
634  // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18 scenario
635  if (ignoreCut(indexNEF_EC_L_) ||
636  (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
637  passCut(ret, indexNEF_EC_L_);
638  if (ignoreCut(indexNEF_EC_U_) ||
639  (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
640  passCut(ret, indexNEF_EC_U_);
641  if (ignoreCut(indexNNeutrals_EC_) ||
642  (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
643  passCut(ret, indexNNeutrals_EC_);
644 
645  // Cuts for |eta| > 3.0 for SUMMER18 scenario
646  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
647  passCut(ret, indexNHF_FW_);
648  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
649  passCut(ret, indexNEF_FW_);
650  if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
651  passCut(ret, indexNNeutrals_FW_);
652  }
653 
654  else if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI) || (version_ == RUN3PUPPIrunsBCDEprompt) ||
655  (version_ == RUN3PUPPIruns2022FGruns2023CD)) {
656  // Cuts for |eta| <= 2.6 for SUMMER18PUPPI scenario
657  if (ignoreCut(indexNConstituents_) ||
658  (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
659  passCut(ret, indexNConstituents_);
660  if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
661  passCut(ret, indexNEF_);
662  if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
663  passCut(ret, indexNHF_);
664  if (quality_ == TIGHTLEPVETO) {
665  if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
666  passCut(ret, indexMUF_);
667  if (ignoreCut(indexCEF_) || (cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > 2.6)) //edw
668  passCut(ret, indexCEF_);
669  }
670 
671  // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18PUPPI scenario
672  if (ignoreCut(indexNHF_TR_) ||
673  (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
674  passCut(ret, indexNHF_TR_);
675  if (ignoreCut(indexNEF_TR_) ||
676  (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
677  passCut(ret, indexNEF_TR_);
678  if (quality_ == TIGHTLEPVETO) {
679  if (ignoreCut(indexMUF_TR_) ||
680  (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
681  passCut(ret, indexMUF_TR_);
682  if (ignoreCut(indexCEF_TR_) ||
683  (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
684  passCut(ret, indexCEF_TR_);
685  }
686 
687  // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18PUPPI scenario
688  if (ignoreCut(indexNHF_EC_) ||
689  (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
690  passCut(ret, indexNHF_EC_);
691 
692  // Cuts for |eta| > 3.0 for SUMMER18PUPPI scenario
693  if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
694  passCut(ret, indexNHF_FW_);
695  if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
696  passCut(ret, indexNEF_FW_);
697  if (ignoreCut(indexNNeutrals_FW_L_) ||
698  (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
699  passCut(ret, indexNNeutrals_FW_L_);
700  if (ignoreCut(indexNNeutrals_FW_U_) ||
701  (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
702  passCut(ret, indexNNeutrals_FW_U_);
703  }
704 
705  //std::cout << "<PFJetIDSelectionFunctor::firstDataCuts>:" << std::endl;
706  //std::cout << " jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << std::endl;
707  //ret.print(std::cout);
708  setIgnored(ret);
709  return (bool)ret;
710  }
Selector< pat::Jet >::ignoreCut
bool ignoreCut(std::string const &s) const
ignore the cut at index "s"
Definition: Selector.h:127
pat::Jet::muonEnergy
float muonEnergy() const
muonEnergy
Definition: Jet.h:428
reco::PFJet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: PFJet.h:99
reco::PFJet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: PFJet.h:152
pat::Jet::chargedMultiplicity
int chargedMultiplicity() const
chargedMultiplicity
Definition: Jet.h:740
reco::PFJet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: PFJet.h:139
reco::PFJet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: PFJet.h:147
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:761
reco::candidate::const_iterator
Definition: const_iterator.h:14
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:464
Selector< pat::Jet >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:181
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
reco::PFJet::neutralMultiplicity
int neutralMultiplicity() const
neutralMultiplicity
Definition: PFJet.h:154
reco::BasicJet
Jets made from CaloTowers.
Definition: BasicJet.h:19
pat::Jet::neutralHadronEnergyFraction
float neutralHadronEnergyFraction() const
neutralHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:402
cms::cuda::assert
assert(be >=bs)
reco::PFJet
Jets made from PFObjects.
Definition: PFJet.h:20
pat::Jet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: Jet.h:694
Selector< pat::Jet >::passCut
void passCut(pat::strbitset &ret, std::string const &s)
Passing cuts.
Definition: Selector.h:142
reco::PFJet::electronEnergy
float electronEnergy() const
electronEnergy
Definition: PFJet.h:107
reco::Candidate::end
const_iterator end() const
last daughter const_iterator
Definition: Candidate.h:145
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
pat::Jet::chargedEmEnergy
float chargedEmEnergy() const
chargedEmEnergy
Definition: Jet.h:712
pat::Jet::isPFJet
bool isPFJet() const
check to see if the jet is a reco::PFJet
Definition: Jet.h:275
pat::Jet::neutralHadronEnergy
float neutralHadronEnergy() const
neutralHadronEnergy
Definition: Jet.h:704
pat::Jet::chargedHadronEnergyFraction
float chargedHadronEnergyFraction() const
chargedHadronEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:398
reco::PFJet::HFEMEnergy
float HFEMEnergy() const
HFEMEnergy.
Definition: PFJet.h:119
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
pat::Jet
Analysis-level calorimeter jet class.
Definition: Jet.h:77
reco::PFJet::muonEnergy
float muonEnergy() const
muonEnergy
Definition: PFJet.h:111
pat::Jet::chargedEmEnergyFraction
float chargedEmEnergyFraction() const
chargedEmEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:406
pat::Jet::muonEnergyFraction
float muonEnergyFraction() const
muonEnergyFraction (relative to corrected jet energy)
Definition: Jet.h:430
pat::Jet::neutralEmEnergy
float neutralEmEnergy() const
neutralEmEnergy
Definition: Jet.h:722
pat::Jet::neutralEmEnergyFraction
float neutralEmEnergyFraction() const
neutralEmEnergyFraction (relative to uncorrected jet energy)
Definition: Jet.h:410
reco::PFJet::chargedHadronEnergy
float chargedHadronEnergy() const
chargedHadronEnergy
Definition: PFJet.h:95
reco::PFJet::photonEnergy
float photonEnergy() const
photonEnergy
Definition: PFJet.h:103
reco::Candidate::begin
const_iterator begin() const
first daughter const_iterator
Definition: Candidate.h:143
reco::LeafCandidate::energy
double energy() const final
energy
Definition: LeafCandidate.h:125

◆ getDescription()

static edm::ParameterSetDescription PFJetIDSelectionFunctor::getDescription ( )
inlinestatic

Definition at line 132 of file PFJetIDSelectionFunctor.h.

References HLT_2023v12_cff::CEF, HLT_2023v12_cff::CHF, submitPVResolutionJobs::desc, HLT_2023v12_cff::NCH, custom_jme_cff::nConstituents, HLT_2023v12_cff::NEF, and HLT_2023v12_cff::NHF.

132  {
133  edm::ParameterSetDescription desc;
134 
135  desc.ifValue(
136  edm::ParameterDescription<std::string>("version", "RUN3PUPPIruns2022FGruns2023CD", true, edm::Comment("")),
137  edm::allowedValues<std::string>("FIRSTDATA",
138  "RUNIISTARTUP",
139  "WINTER16",
140  "WINTER17",
141  "WINTER17PUPPI",
142  "SUMMER18",
143  "SUMMER18PUPPI",
144  "RUN2UL16CHS",
145  "RUN2UL16PUPPI",
146  "RUN2ULCHS",
147  "RUN2ULPUPPI",
148  "RUN3CHSrunsBCDEprompt",
149  "RUN3PUPPIrunsBCDEprompt",
150  "RUN3CHSruns2022FGruns2023CD",
151  "RUN3PUPPIruns2022FGruns2023CD"));
152  desc.ifValue(edm::ParameterDescription<std::string>("quality", "TIGHT", true, edm::Comment("")),
153  edm::allowedValues<std::string>("LOOSE", "TIGHT", "TIGHTLEPVETO"));
154  desc.addOptional<std::vector<std::string>>("cutsToIgnore")->setComment("");
155 
156  edm::ParameterDescription<double> CHF("CHF", true, edm::Comment(""));
157  edm::ParameterDescription<double> NHF("NHF", true, edm::Comment(""));
158  edm::ParameterDescription<double> NHF_FW("NHF_FW", true, edm::Comment(""));
159  edm::ParameterDescription<double> NHF_EC("NHF_EC", true, edm::Comment(""));
160  edm::ParameterDescription<double> NHF_TR("NHF_TR", true, edm::Comment(""));
161 
162  edm::ParameterDescription<double> CEF("CEF", true, edm::Comment(""));
163  edm::ParameterDescription<double> CEF_TR("CEF_TR", true, edm::Comment(""));
164 
165  edm::ParameterDescription<double> NEF("NEF", true, edm::Comment(""));
166  edm::ParameterDescription<double> NEF_FW("NEF_FW", true, edm::Comment(""));
167  edm::ParameterDescription<double> NEF_EC_L("NEF_EC_L", true, edm::Comment(""));
168  edm::ParameterDescription<double> NEF_EC_U("NEF_EC_U", true, edm::Comment(""));
169  edm::ParameterDescription<double> NEF_TR("NEF_TR", true, edm::Comment(""));
170 
171  edm::ParameterDescription<int> NCH("NCH", true, edm::Comment(""));
172 
173  edm::ParameterDescription<double> MUF("MUF", true, edm::Comment(""));
174  edm::ParameterDescription<double> MUF_TR("MUF_TR", true, edm::Comment(""));
175 
176  edm::ParameterDescription<int> nConstituents("nConstituents", true, edm::Comment(""));
177  edm::ParameterDescription<int> nNeutrals_FW("nNeutrals_FW", true, edm::Comment(""));
178  edm::ParameterDescription<int> nNeutrals_FW_L("nNeutrals_FW_L", true, edm::Comment(""));
179  edm::ParameterDescription<int> nNeutrals_FW_U("nNeutrals_FW_U", true, edm::Comment(""));
180  edm::ParameterDescription<int> nnNeutrals_EC("nNeutrals_EC", true, edm::Comment(""));
181 
182  desc.addOptionalNode(CHF, false);
183  desc.addOptionalNode(NHF, false);
184  desc.addOptionalNode(NHF_FW, false);
185  desc.addOptionalNode(NHF_EC, false);
186  desc.addOptionalNode(NHF_TR, false);
187 
188  desc.addOptionalNode(CEF, false);
189  desc.addOptionalNode(CEF_TR, false);
190 
191  desc.addOptionalNode(NEF, false);
192  desc.addOptionalNode(NEF_FW, false);
193  desc.addOptionalNode(NEF_EC_L, false);
194  desc.addOptionalNode(NEF_EC_U, false);
195  desc.addOptionalNode(NEF_TR, false);
196 
197  desc.addOptionalNode(NCH, false);
198 
199  desc.addOptionalNode(MUF, false);
200  desc.addOptionalNode(MUF_TR, false);
201 
202  desc.addOptionalNode(nConstituents, false);
203  desc.addOptionalNode(nNeutrals_FW, false);
204  desc.addOptionalNode(nNeutrals_FW_L, false);
205  desc.addOptionalNode(nNeutrals_FW_U, false);
206  desc.addOptionalNode(nnNeutrals_EC, false);
207 
208  return desc;
209  }
custom_jme_cff.nConstituents
nConstituents
Definition: custom_jme_cff.py:131
HLT_2023v12_cff.CHF
CHF
Definition: HLT_2023v12_cff.py:10791
HLT_2023v12_cff.NEF
NEF
Definition: HLT_2023v12_cff.py:10794
HLT_2023v12_cff.CEF
CEF
Definition: HLT_2023v12_cff.py:10793
HLT_2023v12_cff.NCH
NCH
Definition: HLT_2023v12_cff.py:10796
HLT_2023v12_cff.NHF
NHF
Definition: HLT_2023v12_cff.py:10792

◆ initCuts()

void PFJetIDSelectionFunctor::initCuts ( )
inlineprivate

Definition at line 713 of file PFJetIDSelectionFunctor.h.

References LOOSE, Selector< pat::Jet >::push_back(), quality_, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by PFJetIDSelectionFunctor().

713  {
714  push_back("CHF");
715  push_back("NHF");
716  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
717  version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI &&
718  version_ != RUN3CHSrunsBCDEprompt && version_ != RUN3PUPPIrunsBCDEprompt &&
719  version_ != RUN3CHSruns2022FGruns2023CD && version_ != RUN3PUPPIruns2022FGruns2023CD) ||
720  quality_ != TIGHT)
721  push_back("CEF");
722  push_back("NEF");
723  push_back("NCH");
724  push_back("nConstituents");
725  if (version_ == RUNIISTARTUP) {
726  push_back("NEF_FW");
727  push_back("nNeutrals_FW");
728  }
729  if (version_ == WINTER16) {
730  push_back("NHF_EC");
731  push_back("NEF_EC");
732  push_back("nNeutrals_EC");
733  push_back("NEF_FW");
734  push_back("nNeutrals_FW");
735  if (quality_ == TIGHTLEPVETO)
736  push_back("MUF");
737  }
738  if (version_ == WINTER17) {
739  push_back("NEF_EC_L");
740  push_back("NEF_EC_U");
741  push_back("nNeutrals_EC");
742  push_back("NEF_FW");
743  push_back("NHF_FW");
744  push_back("nNeutrals_FW");
745  if (quality_ == TIGHTLEPVETO)
746  push_back("MUF");
747  }
748  if (version_ == WINTER17PUPPI) {
749  push_back("NHF_EC");
750  push_back("NEF_FW");
751  push_back("NHF_FW");
752  push_back("nNeutrals_FW_L");
753  push_back("nNeutrals_FW_U");
754  if (quality_ == TIGHTLEPVETO)
755  push_back("MUF");
756  }
757  if (version_ == RUN2UL16CHS) {
758  push_back("NHF_TR");
759  push_back("NEF_TR");
760  push_back("NHF_EC");
761  push_back("NEF_EC_L");
762  push_back("NEF_EC_U");
763  push_back("nNeutrals_EC");
764  push_back("NEF_FW");
765  push_back("NHF_FW");
766  push_back("nNeutrals_FW");
767 
768  if (quality_ == TIGHTLEPVETO) {
769  push_back("MUF");
770  }
771  }
772  if (version_ == RUN2UL16PUPPI) {
773  push_back("NHF_TR");
774  push_back("NEF_TR");
775  push_back("nNeutrals_EC");
776  push_back("NEF_FW");
777  push_back("nNeutrals_FW_L");
778  push_back("nNeutrals_FW_U");
779 
780  if (quality_ == TIGHTLEPVETO) {
781  push_back("MUF");
782  }
783  }
784  if ((version_ == SUMMER18) || (version_ == RUN2ULCHS)) {
785  push_back("NHF_TR");
786  push_back("NEF_TR");
787  push_back("NCH_TR");
788  push_back("NEF_EC_L");
789  push_back("NEF_EC_U");
790  push_back("nNeutrals_EC");
791  push_back("NEF_FW");
792  push_back("NHF_FW");
793  push_back("nNeutrals_FW");
794 
795  if (quality_ == TIGHTLEPVETO) {
796  push_back("MUF");
797  push_back("MUF_TR");
798  push_back("CEF_TR");
799  }
800  }
801  if (version_ == RUN3CHSrunsBCDEprompt) {
802  push_back("NHF_TR");
803  push_back("NEF_TR");
804  push_back("NCH_TR");
805  push_back("NEF_EC_U");
806  push_back("nNeutrals_EC");
807  push_back("NEF_FW");
808  push_back("NHF_FW");
809  push_back("nNeutrals_FW");
810 
811  if (quality_ == TIGHTLEPVETO) {
812  push_back("CEF");
813  push_back("MUF");
814  push_back("MUF_TR");
815  push_back("CEF_TR");
816  }
817  }
818  if (version_ == RUN3CHSruns2022FGruns2023CD) {
819  push_back("NHF_TR");
820  push_back("NEF_TR");
821  push_back("NCH_TR");
822  push_back("NHF_EC");
823  push_back("NEF_EC_U");
824  push_back("nNeutrals_EC");
825  push_back("NEF_FW");
826  push_back("nNeutrals_FW");
827 
828  if (quality_ == TIGHTLEPVETO) {
829  push_back("CEF");
830  push_back("MUF");
831  push_back("MUF_TR");
832  push_back("CEF_TR");
833  }
834  }
835  if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI)) {
836  push_back("NHF_TR");
837  push_back("NEF_TR");
838  push_back("NHF_EC");
839  push_back("NEF_FW");
840  push_back("NHF_FW");
841  push_back("nNeutrals_FW_L");
842  push_back("nNeutrals_FW_U");
843 
844  if (quality_ == TIGHTLEPVETO) {
845  push_back("MUF");
846  push_back("MUF_TR");
847  push_back("CEF_TR");
848  }
849  }
850  if ((version_ == RUN3PUPPIrunsBCDEprompt) || (version_ == RUN3PUPPIruns2022FGruns2023CD)) {
851  push_back("NHF_TR");
852  push_back("NEF_TR");
853  push_back("NHF_EC");
854  push_back("NEF_FW");
855  push_back("nNeutrals_FW_L");
856 
857  if (quality_ == TIGHTLEPVETO) {
858  push_back("CEF");
859  push_back("MUF");
860  push_back("MUF_TR");
861  push_back("CEF_TR");
862  }
863  }
864  if ((version_ == WINTER17 || version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI ||
865  version_ == RUN2UL16CHS || version_ == RUN2UL16PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI ||
866  version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
867  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD) &&
868  quality_ == LOOSE) {
869  edm::LogWarning("BadJetIDVersion")
870  << "The LOOSE operating point is only supported for the WINTER16 JetID version -- defaulting to TIGHT";
871  quality_ = TIGHT;
872  }
873 
874  // Set some default cuts for LOOSE, TIGHT
875  if (quality_ == LOOSE) {
876  set("CHF", 0.0);
877  set("NHF", 0.99);
878  set("CEF", 0.99);
879  set("NEF", 0.99);
880  set("NCH", 0);
881  set("nConstituents", 1);
882  if (version_ == RUNIISTARTUP) {
883  set("NEF_FW", 0.90);
884  set("nNeutrals_FW", 10);
885  } else if (version_ == WINTER16) {
886  set("NHF_EC", 0.98);
887  set("NEF_EC", 0.01);
888  set("nNeutrals_EC", 2);
889  set("NEF_FW", 0.90);
890  set("nNeutrals_FW", 10);
891  }
892  } else if (quality_ == TIGHT) {
893  set("CHF", 0.0);
894  set("NHF", 0.9);
895  if (version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
896  version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI &&
897  version_ != RUN3CHSrunsBCDEprompt && version_ != RUN3PUPPIrunsBCDEprompt &&
898  version_ != RUN3CHSruns2022FGruns2023CD && version_ != RUN3PUPPIruns2022FGruns2023CD)
899  set("CEF", 0.99);
900  if (version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
901  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD)
902  set("CHF", 0.01);
903  if (version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD)
904  set("NHF", 0.99);
905  set("NEF", 0.9);
906  set("NCH", 0);
907  set("nConstituents", 1);
908  if (version_ == RUNIISTARTUP) {
909  set("NEF_FW", 0.90);
910  set("nNeutrals_FW", 10);
911  } else if (version_ == WINTER16) {
912  set("NHF_EC", 0.98);
913  set("NEF_EC", 0.01);
914  set("nNeutrals_EC", 2);
915  set("NEF_FW", 0.90);
916  set("nNeutrals_FW", 10);
917  } else if (version_ == WINTER17) {
918  set("NEF_EC_L", 0.02);
919  set("NEF_EC_U", 0.99);
920  set("nNeutrals_EC", 2);
921  set("NHF_FW", 0.02);
922  set("NEF_FW", 0.90);
923  set("nNeutrals_FW", 10);
924  } else if (version_ == WINTER17PUPPI) {
925  set("NHF_EC", 0.99);
926  set("NHF_FW", 0.02);
927  set("NEF_FW", 0.90);
928  set("nNeutrals_FW_L", 2);
929  set("nNeutrals_FW_U", 15);
930  } else if (version_ == SUMMER18) {
931  set("NHF_TR", 0.9);
932  set("NEF_TR", 0.99);
933  set("NCH_TR", 0);
934  set("NEF_EC_L", 0.02);
935  set("NEF_EC_U", 0.99);
936  set("nNeutrals_EC", 2);
937  set("NHF_FW", 0.2);
938  set("NEF_FW", 0.90);
939  set("nNeutrals_FW", 10);
940  } else if (version_ == SUMMER18PUPPI) {
941  set("NHF_TR", 0.9);
942  set("NEF_TR", 0.99);
943  set("NHF_EC", 0.99);
944  set("NHF_FW", 0.02);
945  set("NEF_FW", 0.90);
946  set("nNeutrals_FW_L", 2);
947  set("nNeutrals_FW_U", 15);
948  } else if (version_ == RUN2UL16CHS) {
949  set("NHF_TR", 0.9);
950  set("NEF_TR", 0.99);
951  set("NHF_EC", 0.9);
952  set("NEF_EC_L", 0.);
953  set("NEF_EC_U", 0.99);
954  set("nNeutrals_EC", 1);
955  set("NHF_FW", 0.2);
956  set("NEF_FW", 0.90);
957  set("nNeutrals_FW", 10);
958  } else if (version_ == RUN2UL16PUPPI) {
959  set("NHF_TR", 0.98);
960  set("NEF_TR", 0.99);
961  set("nNeutrals_EC", 1);
962  set("NEF_FW", 0.90);
963  set("nNeutrals_FW_L", 2);
964  set("nNeutrals_FW_U", 999999);
965  } else if (version_ == RUN2ULCHS) {
966  set("NHF_TR", 0.9);
967  set("NEF_TR", 0.99);
968  set("NCH_TR", 0);
969  set("NEF_EC_L", 0.01);
970  set("NEF_EC_U", 0.99);
971  set("nNeutrals_EC", 1);
972  set("NHF_FW", 0.2);
973  set("NEF_FW", 0.90);
974  set("nNeutrals_FW", 10);
975  } else if (version_ == RUN3CHSrunsBCDEprompt) {
976  set("NHF_TR", 0.9);
977  set("NEF_TR", 0.99);
978  set("NCH_TR", 0);
979  set("NEF_EC_U", 0.99);
980  set("nNeutrals_EC", 1);
981  set("NHF_FW", 0.2);
982  set("NEF_FW", 0.90);
983  set("nNeutrals_FW", 10);
984  } else if (version_ == RUN3CHSruns2022FGruns2023CD) {
985  set("NHF_TR", 0.9);
986  set("NEF_TR", 0.99);
987  set("NCH_TR", 0);
988  set("NEF_EC_U", 0.99);
989  set("NHF_EC", 0.99);
990  set("nNeutrals_EC", 1);
991  set("NEF_FW", 0.4);
992  set("nNeutrals_FW", 10);
993  } else if (version_ == RUN2ULPUPPI) {
994  set("NHF_TR", 0.9);
995  set("NEF_TR", 0.99);
996  set("NHF_EC", 0.99);
997  set("NHF_FW", -1.0);
998  set("NEF_FW", 0.4);
999  set("nNeutrals_FW_L", 2);
1000  set("nNeutrals_FW_U", 999999);
1001  } else if (version_ == RUN3PUPPIrunsBCDEprompt) {
1002  set("NHF_TR", 0.9);
1003  set("NEF_TR", 0.99);
1004  set("NHF_EC", 0.9999);
1005  set("NEF_FW", 0.90);
1006  set("nNeutrals_FW_L", 2);
1007  } else if (version_ == RUN3PUPPIruns2022FGruns2023CD) {
1008  set("NHF_TR", 0.9);
1009  set("NEF_TR", 0.99);
1010  set("NHF_EC", 0.99);
1011  set("NEF_FW", 0.4);
1012  set("nNeutrals_FW_L", 1);
1013  }
1014  } else if (quality_ == TIGHTLEPVETO) {
1015  set("CHF", 0.0);
1016  set("NHF", 0.9);
1017  set("CEF", 0.8);
1018  set("NEF", 0.9);
1019  set("NCH", 0);
1020  set("nConstituents", 1);
1021  set("MUF", 0.8);
1022  if (version_ == WINTER17) {
1023  set("NEF_EC_L", 0.02);
1024  set("NEF_EC_U", 0.99);
1025  set("nNeutrals_EC", 2);
1026  set("NHF_FW", 0.02);
1027  set("NEF_FW", 0.90);
1028  set("nNeutrals_FW", 10);
1029  }
1030  if (version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
1031  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD) {
1032  set("CHF", 0.01);
1033  } else if (version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD) {
1034  set("NHF", 0.99);
1035  } else if (version_ == WINTER17PUPPI) {
1036  set("NHF_EC", 0.99);
1037  set("NHF_FW", 0.02);
1038  set("NEF_FW", 0.90);
1039  set("nNeutrals_FW_L", 2);
1040  set("nNeutrals_FW_U", 15);
1041  } else if (version_ == WINTER16) {
1042  set("CEF", 0.9);
1043  set("NEF_EC", 0.01);
1044  set("NHF_EC", 0.98);
1045  set("nNeutrals_EC", 2);
1046  set("nNeutrals_FW", 10);
1047  set("NEF_FW", 0.90);
1048  } else if (version_ == WINTER17PUPPI) {
1049  set("NHF_EC", 0.99);
1050  set("NHF_FW", 0.02);
1051  set("NEF_FW", 0.90);
1052  set("nNeutrals_FW_L", 2);
1053  set("nNeutrals_FW_U", 15);
1054  } else if (version_ == WINTER16) {
1055  set("CEF", 0.9);
1056  set("NEF_EC", 0.01);
1057  set("NHF_EC", 0.98);
1058  set("nNeutrals_EC", 2);
1059  set("nNeutrals_FW", 10);
1060  set("NEF_FW", 0.90);
1061  } else if (version_ == SUMMER18) {
1062  set("NHF_TR", 0.9);
1063  set("NEF_TR", 0.99);
1064  set("MUF_TR", 0.8);
1065  set("NCH_TR", 0);
1066  set("CEF_TR", 0.8);
1067  set("NEF_EC_L", 0.02);
1068  set("NEF_EC_U", 0.99);
1069  set("nNeutrals_EC", 2);
1070  set("NHF_FW", 0.2);
1071  set("NEF_FW", 0.90);
1072  set("nNeutrals_FW", 10);
1073  } else if (version_ == SUMMER18PUPPI) {
1074  set("NHF_TR", 0.9);
1075  set("NEF_TR", 0.99);
1076  set("MUF_TR", 0.8);
1077  set("CEF_TR", 0.8);
1078  set("NHF_EC", 0.99);
1079  set("NHF_FW", 0.02);
1080  set("NEF_FW", 0.90);
1081  set("nNeutrals_FW_L", 2);
1082  set("nNeutrals_FW_U", 15);
1083  } else if (version_ == RUN2UL16CHS) {
1084  set("NHF_TR", 0.9);
1085  set("NEF_TR", 0.99);
1086  set("NHF_EC", 0.9);
1087  set("NEF_EC_L", 0.);
1088  set("NEF_EC_U", 0.99);
1089  set("nNeutrals_EC", 1);
1090  set("NHF_FW", 0.2);
1091  set("NEF_FW", 0.90);
1092  set("nNeutrals_FW", 10);
1093  } else if (version_ == RUN2UL16PUPPI) {
1094  set("NHF_TR", 0.98);
1095  set("NEF_TR", 0.99);
1096  set("nNeutrals_EC", 1);
1097  set("NEF_FW", 0.90);
1098  set("nNeutrals_FW_L", 2);
1099  set("nNeutrals_FW_U", 999999);
1100  } else if (version_ == RUN2ULCHS) {
1101  set("NHF_TR", 0.9);
1102  set("NEF_TR", 0.99);
1103  set("MUF_TR", 0.8);
1104  set("NCH_TR", 0);
1105  set("CEF_TR", 0.8);
1106  set("NEF_EC_L", 0.01);
1107  set("NEF_EC_U", 0.99);
1108  set("nNeutrals_EC", 1);
1109  set("NHF_FW", 0.2);
1110  set("NEF_FW", 0.90);
1111  set("nNeutrals_FW", 10);
1112  } else if (version_ == RUN3CHSrunsBCDEprompt) {
1113  set("MUF_TR", 0.8);
1114  set("CEF_TR", 0.8);
1115  set("NHF_TR", 0.9);
1116  set("NEF_TR", 0.99);
1117  set("NCH_TR", 0);
1118  set("NEF_EC_U", 0.99);
1119  set("nNeutrals_EC", 1);
1120  set("NHF_FW", 0.2);
1121  set("NEF_FW", 0.90);
1122  set("nNeutrals_FW", 10);
1123  } else if (version_ == RUN3CHSruns2022FGruns2023CD) {
1124  set("MUF_TR", 0.8);
1125  set("CEF_TR", 0.8);
1126  set("NHF_TR", 0.9);
1127  set("NEF_TR", 0.99);
1128  set("NCH_TR", 0);
1129  set("NEF_EC_U", 0.99);
1130  set("NHF_EC", 0.99);
1131  set("nNeutrals_EC", 1);
1132  set("NEF_FW", 0.4);
1133  set("nNeutrals_FW", 10);
1134  } else if (version_ == RUN2ULPUPPI) {
1135  set("NHF_TR", 0.9);
1136  set("NEF_TR", 0.99);
1137  set("MUF_TR", 0.8);
1138  set("CEF_TR", 0.8);
1139  set("NHF_EC", 0.9999);
1140  set("NHF_FW", -1.0);
1141  set("NEF_FW", 0.90);
1142  set("nNeutrals_FW_L", 2);
1143  set("nNeutrals_FW_U", 999999);
1144  } else if (version_ == RUN3PUPPIrunsBCDEprompt) {
1145  set("MUF_TR", 0.8);
1146  set("CEF_TR", 0.8);
1147  set("NHF_TR", 0.9);
1148  set("NEF_TR", 0.99);
1149  set("NHF_EC", 0.9999);
1150  set("NEF_FW", 0.90);
1151  set("nNeutrals_FW_L", 2);
1152  } else if (version_ == RUN3PUPPIruns2022FGruns2023CD) {
1153  set("MUF_TR", 0.8);
1154  set("CEF_TR", 0.8);
1155  set("NHF_TR", 0.9);
1156  set("NEF_TR", 0.99);
1157  set("NHF_EC", 0.99);
1158  set("NEF_FW", 0.4);
1159  set("nNeutrals_FW_L", 1);
1160  }
1161  }
1162  }
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
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:128

◆ initIndex()

void PFJetIDSelectionFunctor::initIndex ( )
inlineprivate

Definition at line 1164 of file PFJetIDSelectionFunctor.h.

References Selector< pat::Jet >::bits_, Selector< pat::Jet >::getBitTemplate(), indexCEF_, indexCEF_TR_, indexCHF_, indexMUF_, indexMUF_TR_, indexNCH_, indexNCH_TR_, indexNConstituents_, indexNEF_, indexNEF_EC_, indexNEF_EC_L_, indexNEF_EC_U_, indexNEF_FW_, indexNEF_TR_, indexNHF_, indexNHF_EC_, indexNHF_FW_, indexNHF_TR_, indexNNeutrals_EC_, indexNNeutrals_FW_, indexNNeutrals_FW_L_, indexNNeutrals_FW_U_, quality_, Selector< pat::Jet >::retInternal_, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by PFJetIDSelectionFunctor().

1164  {
1165  indexNConstituents_ = index_type(&bits_, "nConstituents");
1166  indexNEF_ = index_type(&bits_, "NEF");
1167  indexNHF_ = index_type(&bits_, "NHF");
1168  if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
1169  version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI &&
1170  version_ != RUN3CHSrunsBCDEprompt && version_ != RUN3PUPPIrunsBCDEprompt &&
1171  version_ != RUN3CHSruns2022FGruns2023CD && version_ != RUN3PUPPIruns2022FGruns2023CD) ||
1172  quality_ != TIGHT)
1173  indexCEF_ = index_type(&bits_, "CEF");
1174 
1175  indexCHF_ = index_type(&bits_, "CHF");
1176  indexNCH_ = index_type(&bits_, "NCH");
1177  if (version_ == RUNIISTARTUP) {
1178  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1179  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
1180  }
1181  if (version_ == WINTER16) {
1182  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
1183  indexNEF_EC_ = index_type(&bits_, "NEF_EC");
1184  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
1185  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1186  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
1187  if (quality_ == TIGHTLEPVETO) {
1188  indexMUF_ = index_type(&bits_, "MUF");
1189  }
1190  }
1191  if (version_ == WINTER17) {
1192  indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
1193  indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
1194  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
1195  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
1196  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1197  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
1198  if (quality_ == TIGHTLEPVETO) {
1199  indexMUF_ = index_type(&bits_, "MUF");
1200  }
1201  }
1202  if (version_ == WINTER17PUPPI) {
1203  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
1204  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
1205  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1206  indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
1207  indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
1208  if (quality_ == TIGHTLEPVETO) {
1209  indexMUF_ = index_type(&bits_, "MUF");
1210  }
1211  }
1212  if ((version_ == SUMMER18) || (version_ == RUN2ULCHS) || (version_ == RUN3CHSrunsBCDEprompt) ||
1213  (version_ == RUN3CHSruns2022FGruns2023CD)) {
1214  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
1215  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
1216  indexNCH_TR_ = index_type(&bits_, "NCH_TR");
1217  indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
1218  indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
1219  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
1220  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
1221  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1222  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
1223  if (quality_ == TIGHTLEPVETO) {
1224  indexMUF_ = index_type(&bits_, "MUF");
1225  indexMUF_TR_ = index_type(&bits_, "MUF_TR");
1226  indexCEF_TR_ = index_type(&bits_, "CEF_TR");
1227  }
1228  }
1229  if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI) || (version_ == RUN3PUPPIrunsBCDEprompt) ||
1230  (version_ == RUN3PUPPIruns2022FGruns2023CD)) {
1231  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
1232  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
1233  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
1234  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
1235  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1236  indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
1237  indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
1238  if (quality_ == TIGHTLEPVETO) {
1239  indexMUF_ = index_type(&bits_, "MUF");
1240  indexMUF_TR_ = index_type(&bits_, "MUF_TR");
1241  indexCEF_TR_ = index_type(&bits_, "CEF_TR");
1242  }
1243  }
1244  if (version_ == RUN2UL16CHS) {
1245  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
1246  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
1247  indexNHF_EC_ = index_type(&bits_, "NHF_EC");
1248  indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
1249  indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
1250  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
1251  indexNHF_FW_ = index_type(&bits_, "NHF_FW");
1252  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1253  indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
1254  if (quality_ == TIGHTLEPVETO) {
1255  indexMUF_ = index_type(&bits_, "MUF");
1256  }
1257  }
1258  if (version_ == RUN2UL16PUPPI) {
1259  indexNHF_TR_ = index_type(&bits_, "NHF_TR");
1260  indexNEF_TR_ = index_type(&bits_, "NEF_TR");
1261  indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
1262  indexNEF_FW_ = index_type(&bits_, "NEF_FW");
1263  indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
1264  indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
1265  if (quality_ == TIGHTLEPVETO) {
1266  indexMUF_ = index_type(&bits_, "MUF");
1267  }
1268  }
1269  retInternal_ = getBitTemplate();
1270  }
Selector< pat::Jet >::index_type
pat::strbitset::index_type index_type
Definition: Selector.h:25
Selector< pat::Jet >::retInternal_
pat::strbitset retInternal_
internal ret if users don&#39;t care about return bits
Definition: Selector.h:242
Selector< pat::Jet >::bits_
pat::strbitset bits_
the bitset indexed by strings
Definition: Selector.h:241
Selector< pat::Jet >::getBitTemplate
pat::strbitset getBitTemplate() const
Get an empty bitset with the proper names.
Definition: Selector.h:168

◆ operator()() [1/3]

bool PFJetIDSelectionFunctor::operator() ( const pat::Jet &  t,
pat::strbitset &  ret 
)
inlineoverridevirtual

This provides the interface for base classes to select objects.

Implements Selector< pat::Jet >.

Definition at line 213 of file PFJetIDSelectionFunctor.h.

References FIRSTDATA, firstDataCuts(), metsig::jet, runTheMatrix::ret, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by operator()().

213  {
214  if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
215  version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2UL16CHS ||
216  version_ == RUN2UL16PUPPI || version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
217  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD || version_ == RUN2ULCHS ||
218  version_ == RUN2ULPUPPI) {
219  if (jet.currentJECLevel() == "Uncorrected" || !jet.jecSetsAvailable())
220  return firstDataCuts(jet, ret, version_);
221  else
222  return firstDataCuts(jet.correctedJet("Uncorrected"), ret, version_);
223  } else {
224  return false;
225  }
226  }
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:761
PFJetIDSelectionFunctor::firstDataCuts
bool firstDataCuts(reco::Jet const &jet, pat::strbitset &ret, Version_t version_)
Definition: PFJetIDSelectionFunctor.h:255

◆ operator()() [2/3]

bool PFJetIDSelectionFunctor::operator() ( const reco::PFJet &  jet,
pat::strbitset &  ret 
)
inline

Definition at line 233 of file PFJetIDSelectionFunctor.h.

References FIRSTDATA, firstDataCuts(), metsig::jet, runTheMatrix::ret, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUN3CHSruns2022FGruns2023CD, RUN3CHSrunsBCDEprompt, RUN3PUPPIruns2022FGruns2023CD, RUN3PUPPIrunsBCDEprompt, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, version_, WINTER16, WINTER17, and WINTER17PUPPI.

233  {
234  if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
235  version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2UL16CHS ||
236  version_ == RUN2UL16PUPPI || version_ == RUN3CHSrunsBCDEprompt || version_ == RUN3PUPPIrunsBCDEprompt ||
237  version_ == RUN3CHSruns2022FGruns2023CD || version_ == RUN3PUPPIruns2022FGruns2023CD || version_ == RUN2ULCHS ||
238  version_ == RUN2ULPUPPI) {
239  return firstDataCuts(jet, ret, version_);
240  } else {
241  return false;
242  }
243  }
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:761
PFJetIDSelectionFunctor::firstDataCuts
bool firstDataCuts(reco::Jet const &jet, pat::strbitset &ret, Version_t version_)
Definition: PFJetIDSelectionFunctor.h:255

◆ operator()() [3/3]

bool PFJetIDSelectionFunctor::operator() ( const reco::PFJet &  jet)
inline

Definition at line 245 of file PFJetIDSelectionFunctor.h.

References metsig::jet, operator()(), Selector< pat::Jet >::retInternal_, pat::strbitset::set(), and Selector< pat::Jet >::setIgnored().

245  {
246  retInternal_.set(false);
247  operator()(jet, retInternal_);
248  setIgnored(retInternal_);
249  return (bool)retInternal_;
250  }
Selector< pat::Jet >::setIgnored
void setIgnored(pat::strbitset &ret)
set ignored bits
Definition: Selector.h:181
Selector< pat::Jet >::retInternal_
pat::strbitset retInternal_
internal ret if users don&#39;t care about return bits
Definition: Selector.h:242
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:213
pat::strbitset::set
strbitset & set(bool val=true)
set method of all bits
Definition: strbitset.h:126

Member Data Documentation

◆ indexCEF_

index_type PFJetIDSelectionFunctor::indexCEF_
private

Definition at line 1279 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexCEF_TR_

index_type PFJetIDSelectionFunctor::indexCEF_TR_
private

Definition at line 1287 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexCHF_

index_type PFJetIDSelectionFunctor::indexCHF_
private

Definition at line 1280 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexMUF_

index_type PFJetIDSelectionFunctor::indexMUF_
private

Definition at line 1277 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexMUF_TR_

index_type PFJetIDSelectionFunctor::indexMUF_TR_
private

Definition at line 1286 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNCH_

index_type PFJetIDSelectionFunctor::indexNCH_
private

Definition at line 1281 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNCH_TR_

index_type PFJetIDSelectionFunctor::indexNCH_TR_
private

Definition at line 1285 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNConstituents_

index_type PFJetIDSelectionFunctor::indexNConstituents_
private

Definition at line 1275 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_

index_type PFJetIDSelectionFunctor::indexNEF_
private

Definition at line 1276 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_EC_

index_type PFJetIDSelectionFunctor::indexNEF_EC_
private

Definition at line 1296 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_EC_L_

index_type PFJetIDSelectionFunctor::indexNEF_EC_L_
private

Definition at line 1297 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_EC_U_

index_type PFJetIDSelectionFunctor::indexNEF_EC_U_
private

Definition at line 1298 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_FW_

index_type PFJetIDSelectionFunctor::indexNEF_FW_
private

Definition at line 1290 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNEF_TR_

index_type PFJetIDSelectionFunctor::indexNEF_TR_
private

Definition at line 1284 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNHF_

index_type PFJetIDSelectionFunctor::indexNHF_
private

Definition at line 1278 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNHF_EC_

index_type PFJetIDSelectionFunctor::indexNHF_EC_
private

Definition at line 1295 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNHF_FW_

index_type PFJetIDSelectionFunctor::indexNHF_FW_
private

Definition at line 1289 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNHF_TR_

index_type PFJetIDSelectionFunctor::indexNHF_TR_
private

Definition at line 1283 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNNeutrals_EC_

index_type PFJetIDSelectionFunctor::indexNNeutrals_EC_
private

Definition at line 1299 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNNeutrals_FW_

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_
private

Definition at line 1291 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNNeutrals_FW_L_

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_L_
private

Definition at line 1292 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ indexNNeutrals_FW_U_

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_U_
private

Definition at line 1293 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

◆ quality_

Quality_t PFJetIDSelectionFunctor::quality_
private

Definition at line 1273 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), initCuts(), initIndex(), and PFJetIDSelectionFunctor().

◆ version_

Version_t PFJetIDSelectionFunctor::version_
private

Definition at line 1272 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), initCuts(), initIndex(), operator()(), and PFJetIDSelectionFunctor().

Generated for CMSSW Reference Manual by doxygen 1.8.14