PFJetIDSelectionFunctor Class Reference

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

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

Inheritance diagram for PFJetIDSelectionFunctor:

Public Types
enum	Quality_t { LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY }
enum	Version_t {   FIRSTDATA, RUNIISTARTUP, WINTER16, WINTER17,   WINTER17PUPPI, SUMMER18, SUMMER18PUPPI, RUN2UL16CHS,   RUN2UL16PUPPI, 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::Jetconst &t)
	This provides an alternative signature without the second ret. More...
virtual bool	operator() (pat::Jetconst &t, edm::EventBase const &e, pat::strbitset &ret)
	This provides an alternative signature that includes extra information. More...
virtual bool	operator() (pat::Jetconst &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 ()

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 25 of file PFJetIDSelectionFunctor.h.

Member Enumeration Documentation

enum PFJetIDSelectionFunctor::Quality_t

Enumerator
LOOSE
TIGHT
TIGHTLEPVETO
N_QUALITY

Definition at line 41 of file PFJetIDSelectionFunctor.h.

{ LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY };

enum PFJetIDSelectionFunctor::Version_t

Enumerator
FIRSTDATA
RUNIISTARTUP
WINTER16
WINTER17
WINTER17PUPPI
SUMMER18
SUMMER18PUPPI
RUN2UL16CHS
RUN2UL16PUPPI
RUN2ULCHS
RUN2ULPUPPI
N_VERSIONS

Definition at line 27 of file PFJetIDSelectionFunctor.h.

                 {
    FIRSTDATA,
    RUNIISTARTUP,
    WINTER16,
    WINTER17,
    WINTER17PUPPI,
    SUMMER18,
    SUMMER18PUPPI,
    RUN2UL16CHS,
    RUN2UL16PUPPI,
    RUN2ULCHS,
    RUN2ULPUPPI,
    N_VERSIONS
  };

Constructor & Destructor Documentation

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( )

inline

Definition at line 43 of file PFJetIDSelectionFunctor.h.

{}

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

inline

Definition at line 46 of file PFJetIDSelectionFunctor.h.

      : PFJetIDSelectionFunctor(params) {}

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

inline

Definition at line 50 of file PFJetIDSelectionFunctor.h.

References edm::ParameterSet::exists(), FIRSTDATA, edm::ParameterSet::getParameter(), initCuts(), initIndex(), LOOSE, quality_, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUNIISTARTUP, Selector< pat::Jet >::set(), Selector< pat::Jet >::setIgnoredCuts(), AlCaHLTBitMon_QueryRunRegistry::string, SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

                                                         {
    std::string versionStr = params.getParameter<std::string>("version");
    std::string qualityStr = params.getParameter<std::string>("quality");

    if (versionStr == "FIRSTDATA")
      version_ = FIRSTDATA;
    else if (versionStr == "RUNIISTARTUP")
      version_ = RUNIISTARTUP;
    else if (versionStr == "WINTER16")
      version_ = WINTER16;
    else if (versionStr == "WINTER17")
      version_ = WINTER17;
    else if (versionStr == "WINTER17PUPPI")
      version_ = WINTER17PUPPI;
    else if (versionStr == "SUMMER18")
      version_ = SUMMER18;
    else if (versionStr == "SUMMER18PUPPI")
      version_ = SUMMER18PUPPI;
    else if (versionStr == "RUN2UL16CHS")
      version_ = RUN2UL16CHS;
    else if (versionStr == "RUN2UL16PUPPI")
      version_ = RUN2UL16PUPPI;
    else if (versionStr == "RUN2ULCHS")
      version_ = RUN2ULCHS;
    else if (versionStr == "RUN2ULPUPPI")
      version_ = RUN2ULPUPPI;
    else
      version_ = RUN2ULCHS;  //set RUN2ULCHS as default

    if (qualityStr == "LOOSE")
      quality_ = LOOSE;
    else if (qualityStr == "TIGHT")
      quality_ = TIGHT;
    else if (qualityStr == "TIGHTLEPVETO")
      quality_ = TIGHTLEPVETO;
    else
      quality_ = TIGHT;

    initCuts();

    // Now check the configuration to see if the user changed anything
    if (params.exists("CHF"))
      set("CHF", params.getParameter<double>("CHF"));
    if (params.exists("NHF"))
      set("NHF", params.getParameter<double>("NHF"));
    if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
         version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI) ||
        quality_ != TIGHT) {
      if (params.exists("CEF"))
        set("CEF", params.getParameter<double>("CEF"));
    }
    if (params.exists("NEF"))
      set("NEF", params.getParameter<double>("NEF"));
    if (params.exists("NCH"))
      set("NCH", params.getParameter<int>("NCH"));
    if (params.exists("nConstituents"))
      set("nConstituents", params.getParameter<int>("nConstituents"));
    if (version_ == RUNIISTARTUP) {
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW"))
        set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
    }
    if (version_ == WINTER16) {
      if (params.exists("NHF_EC"))
        set("NHF_EC", params.getParameter<double>("NHF_EC"));
      if (params.exists("NEF_EC"))
        set("NEF_EC", params.getParameter<double>("NEF_EC"));
      if (params.exists("nNeutrals_EC"))
        set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW"))
        set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
      }
    }
    if (version_ == WINTER17) {
      if (params.exists("NEF_EC_L"))
        set("NEF_EC_L", params.getParameter<double>("NEF_EC_L"));
      if (params.exists("NEF_EC_U"))
        set("NEF_EC_U", params.getParameter<double>("NEF_EC_U"));
      if (params.exists("nNeutrals_EC"))
        set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
      if (params.exists("NHF_FW"))
        set("NHF_FW", params.getParameter<double>("NHF_FW"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW"))
        set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
      }
    }
    if (version_ == WINTER17PUPPI) {
      if (params.exists("NHF_EC"))
        set("NHF_EC", params.getParameter<double>("NHF_EC"));
      if (params.exists("NHF_FW"))
        set("NHF_FW", params.getParameter<double>("NHF_FW"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW_L"))
        set("nNeutrals_FW_L", params.getParameter<int>("nNeutrals_FW_L"));
      if (params.exists("nNeutrals_FW_U"))
        set("nNeutrals_FW_U", params.getParameter<int>("nNeutrals_FW_U"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
      }
    }
    if (version_ == RUN2UL16CHS) {
      if (params.exists("NHF_TR"))
        set("NHF_TR", params.getParameter<double>("NHF_TR"));
      if (params.exists("NEF_TR"))
        set("NEF_TR", params.getParameter<double>("NEF_TR"));
      if (params.exists("NHF_EC"))
        set("NHF_EC", params.getParameter<double>("NHF_EC"));
      if (params.exists("NEF_EC_L"))
        set("NEF_EC_L", params.getParameter<double>("NEF_EC_L"));
      if (params.exists("NEF_EC_U"))
        set("NEF_EC_U", params.getParameter<double>("NEF_EC_U"));
      if (params.exists("nNeutrals_EC"))
        set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
      if (params.exists("NHF_FW"))
        set("NHF_FW", params.getParameter<double>("NHF_FW"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW"))
        set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
      }
    }
    if (version_ == RUN2UL16PUPPI) {
      if (params.exists("NHF_TR"))
        set("NHF_TR", params.getParameter<double>("NHF_TR"));
      if (params.exists("NEF_TR"))
        set("NEF_TR", params.getParameter<double>("NEF_TR"));
      if (params.exists("nNeutrals_EC"))
        set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW_L"))
        set("nNeutrals_FW_L", params.getParameter<int>("nNeutrals_FW_L"));
      if (params.exists("nNeutrals_FW_U"))
        set("nNeutrals_FW_U", params.getParameter<int>("nNeutrals_FW_U"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
      }
    }
    if ((version_ == SUMMER18) || (version_ == RUN2ULCHS)) {
      if (params.exists("NHF_TR"))
        set("NHF_TR", params.getParameter<double>("NHF_TR"));
      if (params.exists("NEF_TR"))
        set("NEF_TR", params.getParameter<double>("NEF_TR"));
      if (params.exists("NCH_TR"))
        set("NCH_TR", params.getParameter<int>("NCH_TR"));
      if (params.exists("NEF_EC_L"))
        set("NEF_EC_L", params.getParameter<double>("NEF_EC_L"));
      if (params.exists("NEF_EC_U"))
        set("NEF_EC_U", params.getParameter<double>("NEF_EC_U"));
      if (params.exists("nNeutrals_EC"))
        set("nNeutrals_EC", params.getParameter<int>("nNeutrals_EC"));
      if (params.exists("NHF_FW"))
        set("NHF_FW", params.getParameter<double>("NHF_FW"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW"))
        set("nNeutrals_FW", params.getParameter<int>("nNeutrals_FW"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
        if (params.exists("MUF_TR"))
          set("MUF_TR", params.getParameter<double>("MUF_TR"));
        if (params.exists("CEF_TR"))
          set("CEF_TR", params.getParameter<double>("CEF_TR"));
      }
    }
    if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI)) {
      if (params.exists("NHF_TR"))
        set("NHF_TR", params.getParameter<double>("NHF_TR"));
      if (params.exists("NEF_TR"))
        set("NEF_TR", params.getParameter<double>("NEF_TR"));
      if (params.exists("NHF_EC"))
        set("NHF_EC", params.getParameter<double>("NHF_EC"));
      if (params.exists("NHF_FW"))
        set("NHF_FW", params.getParameter<double>("NHF_FW"));
      if (params.exists("NEF_FW"))
        set("NEF_FW", params.getParameter<double>("NEF_FW"));
      if (params.exists("nNeutrals_FW_L"))
        set("nNeutrals_FW_L", params.getParameter<int>("nNeutrals_FW_L"));
      if (params.exists("nNeutrals_FW_U"))
        set("nNeutrals_FW_U", params.getParameter<int>("nNeutrals_FW_U"));
      if (quality_ == TIGHTLEPVETO) {
        if (params.exists("MUF"))
          set("MUF", params.getParameter<double>("MUF"));
        if (params.exists("MUF_TR"))
          set("MUF_TR", params.getParameter<double>("MUF_TR"));
        if (params.exists("CEF_TR"))
          set("CEF_TR", params.getParameter<double>("CEF_TR"));
      }
    }

    if (params.exists("cutsToIgnore"))
      setIgnoredCuts(params.getParameter<std::vector<std::string> >("cutsToIgnore"));

    initIndex();
  }

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( Version_t  version, Quality_t  quality  )

inline

Definition at line 264 of file PFJetIDSelectionFunctor.h.

References initCuts(), and initIndex().

                                                                : version_(version), quality_(quality) {
    initCuts();
    initIndex();
  }

Member Function Documentation

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

inline

Definition at line 310 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(), alignCSCRings::e, reco::PFJet::electronEnergy(), reco::Candidate::end(), reco::LeafCandidate::energy(), reco::LeafCandidate::eta(), 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, RUNIISTARTUP, pat::strbitset::set(), Selector< pat::Jet >::setIgnored(), SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by operator()().

                                                                                {
    ret.set(false);

    // cache some variables
    double chf = 0.0;
    double nhf = 0.0;
    double cef = 0.0;
    double nef = 0.0;
    double muf = 0.0;

    int nch = 0;
    int nconstituents = 0;
    int nneutrals = 0;

    // Have to do this because pat::Jet inherits from reco::Jet but not reco::PFJet
    reco::PFJet const *pfJet = dynamic_cast<reco::PFJet const *>(&jet);
    pat::Jet const *patJet = dynamic_cast<pat::Jet const *>(&jet);
    reco::BasicJet const *basicJet = dynamic_cast<reco::BasicJet const *>(&jet);

    if (patJet != nullptr) {
      if (patJet->isPFJet()) {
        chf = patJet->chargedHadronEnergyFraction();
        nhf = patJet->neutralHadronEnergyFraction();
        cef = patJet->chargedEmEnergyFraction();
        nef = patJet->neutralEmEnergyFraction();
        nch = patJet->chargedMultiplicity();
        muf = patJet->muonEnergyFraction();
        nconstituents = patJet->neutralMultiplicity() + patJet->chargedMultiplicity();
        nneutrals = patJet->neutralMultiplicity();
      }
      // Handle the special case where this is a composed jet for
      // subjet analyses
      else if (patJet->isBasicJet()) {
        double e_chf = 0.0;
        double e_nhf = 0.0;
        double e_cef = 0.0;
        double e_nef = 0.0;
        double e_muf = 0.0;
        nch = 0;
        nconstituents = 0;
        nneutrals = 0;

        for (reco::Jet::const_iterator ibegin = patJet->begin(), iend = patJet->end(), isub = ibegin; isub != iend;
             ++isub) {
          reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
          pat::Jet const *patsub = dynamic_cast<pat::Jet const *>(&*isub);
          if (patsub) {
            e_chf += patsub->chargedHadronEnergy();
            e_nhf += patsub->neutralHadronEnergy();
            e_cef += patsub->chargedEmEnergy();
            e_nef += patsub->neutralEmEnergy();
            e_muf += patsub->muonEnergy();
            nch += patsub->chargedMultiplicity();
            nconstituents += patsub->neutralMultiplicity() + patsub->chargedMultiplicity();
            nneutrals += patsub->neutralMultiplicity();
          } else if (pfsub) {
            e_chf += pfsub->chargedHadronEnergy();
            e_nhf += pfsub->neutralHadronEnergy();
            e_cef += pfsub->chargedEmEnergy();
            e_nef += pfsub->neutralEmEnergy();
            e_muf += pfsub->muonEnergy();
            nch += pfsub->chargedMultiplicity();
            nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
            nneutrals += pfsub->neutralMultiplicity();
          } else
            assert(0);
        }
        double e = patJet->energy();
        if (e > 0.000001) {
          chf = e_chf / e;
          nhf = e_nhf / e;
          cef = e_cef / e;
          nef = e_nef / e;
          muf = e_muf / e;
        } else {
          chf = nhf = cef = nef = muf = 0.0;
        }
      }
    }  // end if pat jet
    else if (pfJet != nullptr) {
      // CV: need to compute energy fractions in a way that works for corrected as well as for uncorrected PFJets
      double jetEnergyUncorrected = pfJet->chargedHadronEnergy() + pfJet->neutralHadronEnergy() +
                                    pfJet->photonEnergy() + pfJet->electronEnergy() + pfJet->muonEnergy() +
                                    pfJet->HFEMEnergy();
      if (jetEnergyUncorrected > 0.) {
        chf = pfJet->chargedHadronEnergy() / jetEnergyUncorrected;
        nhf = pfJet->neutralHadronEnergy() / jetEnergyUncorrected;
        cef = pfJet->chargedEmEnergy() / jetEnergyUncorrected;
        nef = pfJet->neutralEmEnergy() / jetEnergyUncorrected;
        muf = pfJet->muonEnergy() / jetEnergyUncorrected;
      }
      nch = pfJet->chargedMultiplicity();
      nconstituents = pfJet->neutralMultiplicity() + pfJet->chargedMultiplicity();
      nneutrals = pfJet->neutralMultiplicity();
    }  // end if PF jet
    // Handle the special case where this is a composed jet for
    // subjet analyses
    else if (basicJet != nullptr) {
      double e_chf = 0.0;
      double e_nhf = 0.0;
      double e_cef = 0.0;
      double e_nef = 0.0;
      double e_muf = 0.0;
      nch = 0;
      nconstituents = 0;
      for (reco::Jet::const_iterator ibegin = basicJet->begin(), iend = basicJet->end(), isub = ibegin; isub != iend;
           ++isub) {
        reco::PFJet const *pfsub = dynamic_cast<reco::PFJet const *>(&*isub);
        e_chf += pfsub->chargedHadronEnergy();
        e_nhf += pfsub->neutralHadronEnergy();
        e_cef += pfsub->chargedEmEnergy();
        e_nef += pfsub->neutralEmEnergy();
        e_muf += pfsub->muonEnergy();
        nch += pfsub->chargedMultiplicity();
        nconstituents += pfsub->neutralMultiplicity() + pfsub->chargedMultiplicity();
        nneutrals += pfsub->neutralMultiplicity();
      }
      double e = basicJet->energy();
      if (e > 0.000001) {
        chf = e_chf / e;
        nhf = e_nhf / e;
        cef = e_cef / e;
        nef = e_nef / e;
        muf = e_muf / e;
      }
    }  // end if basic jet

    float etaB = 2.4;
    // Cuts for |eta| < 2.6 for Summer18
    if (version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI)
      etaB = 2.6;
    if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
         version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI) ||
        quality_ != TIGHT) {
      if (ignoreCut(indexCEF_) || (cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > etaB))
        passCut(ret, indexCEF_);
    }
    if (ignoreCut(indexCHF_) || (chf > cut(indexCHF_, double()) || std::abs(jet.eta()) > etaB))
      passCut(ret, indexCHF_);
    if (ignoreCut(indexNCH_) || (nch > cut(indexNCH_, int()) || std::abs(jet.eta()) > etaB))
      passCut(ret, indexNCH_);
    if (version_ == FIRSTDATA) {  // Cuts for all eta for FIRSTDATA
      if (ignoreCut(indexNConstituents_) || (nconstituents > cut(indexNConstituents_, int())))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double())))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double())))
        passCut(ret, indexNHF_);
    } else if (version_ == RUNIISTARTUP) {
      // Cuts for |eta| <= 3.0 for RUNIISTARTUP scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNHF_);
      // Cuts for |eta| > 3.0 for RUNIISTARTUP scenario
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_);
    } else if (version_ == WINTER16) {
      // Cuts for |eta| <= 2.7 for WINTER16 scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.7 < |eta| <= 3.0 for WINTER16 scenario
      if (ignoreCut(indexNHF_EC_) ||
          (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNHF_EC_);
      if (ignoreCut(indexNEF_EC_) ||
          (nef > cut(indexNEF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_);
      if (ignoreCut(indexNNeutrals_EC_) ||
          (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNNeutrals_EC_);

      // Cuts for |eta| > 3.0 for WINTER16 scenario
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_);
    } else if (version_ == WINTER17) {
      // Cuts for |eta| <= 2.7 for WINTER17 scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario

      if (ignoreCut(indexNEF_EC_L_) ||
          (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_L_);
      if (ignoreCut(indexNEF_EC_U_) ||
          (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_U_);
      if (ignoreCut(indexNNeutrals_EC_) ||
          (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNNeutrals_EC_);

      // Cuts for |eta| > 3.0 for WINTER17 scenario
      if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNHF_FW_);
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_);

    } else if (version_ == WINTER17PUPPI) {
      // Cuts for |eta| <= 2.7 for WINTER17 scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.7 < |eta| <= 3.0 for WINTER17 scenario

      if (ignoreCut(indexNHF_EC_) ||
          (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNHF_EC_);

      // Cuts for |eta| > 3.0 for WINTER17 scenario
      if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNHF_FW_);
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_L_) ||
          (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_L_);
      if (ignoreCut(indexNNeutrals_FW_U_) ||
          (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_U_);

    } else if (version_ == RUN2UL16CHS) {
      // Cuts for |eta| <= 2.4 for RUN2UL16CHS scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.4))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.4 <= |eta| <= 2.7 for RUN2UL16CHS scenario
      if (ignoreCut(indexNHF_TR_) ||
          (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_TR_);
      if (ignoreCut(indexNEF_TR_) ||
          (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_TR_);

      // Cuts for 2.7 < |eta| <= 3.0 for RUN2UL16CHS scenario
      if (ignoreCut(indexNHF_EC_) ||
          (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNHF_EC_);
      if (ignoreCut(indexNEF_EC_L_) ||
          (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_L_);
      if (ignoreCut(indexNEF_EC_U_) ||
          (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_U_);
      if (ignoreCut(indexNNeutrals_EC_) ||
          (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNNeutrals_EC_);

      // Cuts for |eta| > 3.0 for RUN2UL16CHS scenario
      if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNHF_FW_);
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_);

    } else if (version_ == RUN2UL16PUPPI) {
      // Cuts for |eta| <= 2.4 for RUN2UL16PUPPI scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.4))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.4))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.4 <= |eta| <= 2.7 for RUN2UL16PUPPI scenario
      if (ignoreCut(indexNHF_TR_) ||
          (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_TR_);
      if (ignoreCut(indexNEF_TR_) ||
          (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.4 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_TR_);

      // Cuts for 2.7 < |eta| <= 3.0 for RUN2UL16PUPPI scenario
      if (ignoreCut(indexNNeutrals_EC_) ||
          (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNNeutrals_EC_);

      // Cuts for |eta| > 3.0 for RUN2UL16PUPPI scenario
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_L_) ||
          (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_L_);
      if (ignoreCut(indexNNeutrals_FW_U_) ||
          (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_U_);

    } else if ((version_ == SUMMER18) || (version_ == RUN2ULCHS)) {
      // Cuts for |eta| <= 2.6 for SUMMER18 scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18 scenario
      if (ignoreCut(indexNHF_TR_) ||
          (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_TR_);
      if (ignoreCut(indexNEF_TR_) ||
          (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_TR_);
      if (ignoreCut(indexNCH_TR_) ||
          (nch > cut(indexNCH_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNCH_TR_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_TR_) ||
            (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexMUF_TR_);
        if (ignoreCut(indexCEF_TR_) ||
            (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexCEF_TR_);
      }

      // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18 scenario
      if (ignoreCut(indexNEF_EC_L_) ||
          (nef > cut(indexNEF_EC_L_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_L_);
      if (ignoreCut(indexNEF_EC_U_) ||
          (nef < cut(indexNEF_EC_U_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNEF_EC_U_);
      if (ignoreCut(indexNNeutrals_EC_) ||
          (nneutrals > cut(indexNNeutrals_EC_, int()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNNeutrals_EC_);

      // Cuts for |eta| > 3.0 for SUMMER18 scenario
      if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNHF_FW_);
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_) || (nneutrals > cut(indexNNeutrals_FW_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_);
    }

    else if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI)) {
      // Cuts for |eta| <= 2.6 for SUMMER18PUPPI scenario
      if (ignoreCut(indexNConstituents_) ||
          (nconstituents > cut(indexNConstituents_, int()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNConstituents_);
      if (ignoreCut(indexNEF_) || (nef < cut(indexNEF_, double()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNEF_);
      if (ignoreCut(indexNHF_) || (nhf < cut(indexNHF_, double()) || std::abs(jet.eta()) > 2.6))
        passCut(ret, indexNHF_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_) || (muf < cut(indexMUF_, double()) || std::abs(jet.eta()) > 2.6))
          passCut(ret, indexMUF_);
      }

      // Cuts for 2.6 <= |eta| <= 2.7 for SUMMER18PUPPI scenario
      if (ignoreCut(indexNHF_TR_) ||
          (nhf < cut(indexNHF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNHF_TR_);
      if (ignoreCut(indexNEF_TR_) ||
          (nef < cut(indexNEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
        passCut(ret, indexNEF_TR_);
      if (quality_ == TIGHTLEPVETO) {
        if (ignoreCut(indexMUF_TR_) ||
            (muf < cut(indexMUF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexMUF_TR_);
        if (ignoreCut(indexCEF_TR_) ||
            (cef < cut(indexCEF_TR_, double()) || std::abs(jet.eta()) <= 2.6 || std::abs(jet.eta()) > 2.7))
          passCut(ret, indexCEF_TR_);
      }

      // Cuts for 2.7 < |eta| <= 3.0 for SUMMER18PUPPI scenario
      if (ignoreCut(indexNHF_EC_) ||
          (nhf < cut(indexNHF_EC_, double()) || std::abs(jet.eta()) <= 2.7 || std::abs(jet.eta()) > 3.0))
        passCut(ret, indexNHF_EC_);

      // Cuts for |eta| > 3.0 for SUMMER18PUPPI scenario
      if (ignoreCut(indexNHF_FW_) || (nhf > cut(indexNHF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNHF_FW_);
      if (ignoreCut(indexNEF_FW_) || (nef < cut(indexNEF_FW_, double()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNEF_FW_);
      if (ignoreCut(indexNNeutrals_FW_L_) ||
          (nneutrals > cut(indexNNeutrals_FW_L_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_L_);
      if (ignoreCut(indexNNeutrals_FW_U_) ||
          (nneutrals < cut(indexNNeutrals_FW_U_, int()) || std::abs(jet.eta()) <= 3.0))
        passCut(ret, indexNNeutrals_FW_U_);
    }

    //std::cout << "<PFJetIDSelectionFunctor::firstDataCuts>:" << std::endl;
    //std::cout << " jet: Pt = " << jet.pt() << ", eta = " << jet.eta() << ", phi = " << jet.phi() << std::endl;
    //ret.print(std::cout);
    setIgnored(ret);
    return (bool)ret;
  }

void PFJetIDSelectionFunctor::initCuts ( )

inlineprivate

Definition at line 758 of file PFJetIDSelectionFunctor.h.

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

Referenced by PFJetIDSelectionFunctor().

                  {
    push_back("CHF");
    push_back("NHF");
    if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
         version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI) ||
        quality_ != TIGHT)
      push_back("CEF");
    push_back("NEF");
    push_back("NCH");
    push_back("nConstituents");
    if (version_ == RUNIISTARTUP) {
      push_back("NEF_FW");
      push_back("nNeutrals_FW");
    }
    if (version_ == WINTER16) {
      push_back("NHF_EC");
      push_back("NEF_EC");
      push_back("nNeutrals_EC");
      push_back("NEF_FW");
      push_back("nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO)
        push_back("MUF");
    }
    if (version_ == WINTER17) {
      push_back("NEF_EC_L");
      push_back("NEF_EC_U");
      push_back("nNeutrals_EC");
      push_back("NEF_FW");
      push_back("NHF_FW");
      push_back("nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO)
        push_back("MUF");
    }
    if (version_ == WINTER17PUPPI) {
      push_back("NHF_EC");
      push_back("NEF_FW");
      push_back("NHF_FW");
      push_back("nNeutrals_FW_L");
      push_back("nNeutrals_FW_U");
      if (quality_ == TIGHTLEPVETO)
        push_back("MUF");
    }
    if (version_ == RUN2UL16CHS) {
      push_back("NHF_TR");
      push_back("NEF_TR");
      push_back("NHF_EC");
      push_back("NEF_EC_L");
      push_back("NEF_EC_U");
      push_back("nNeutrals_EC");
      push_back("NEF_FW");
      push_back("NHF_FW");
      push_back("nNeutrals_FW");

      if (quality_ == TIGHTLEPVETO) {
        push_back("MUF");
      }
    }
    if (version_ == RUN2UL16PUPPI) {
      push_back("NHF_TR");
      push_back("NEF_TR");
      push_back("nNeutrals_EC");
      push_back("NEF_FW");
      push_back("nNeutrals_FW_L");
      push_back("nNeutrals_FW_U");

      if (quality_ == TIGHTLEPVETO) {
        push_back("MUF");
      }
    }
    if ((version_ == SUMMER18) || (version_ == RUN2ULCHS)) {
      push_back("NHF_TR");
      push_back("NEF_TR");
      push_back("NCH_TR");
      push_back("NEF_EC_L");
      push_back("NEF_EC_U");
      push_back("nNeutrals_EC");
      push_back("NEF_FW");
      push_back("NHF_FW");
      push_back("nNeutrals_FW");

      if (quality_ == TIGHTLEPVETO) {
        push_back("MUF");
        push_back("MUF_TR");
        push_back("CEF_TR");
      }
    }
    if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI)) {
      push_back("NHF_TR");
      push_back("NEF_TR");
      push_back("NHF_EC");
      push_back("NEF_FW");
      push_back("NHF_FW");
      push_back("nNeutrals_FW_L");
      push_back("nNeutrals_FW_U");

      if (quality_ == TIGHTLEPVETO) {
        push_back("MUF");
        push_back("MUF_TR");
        push_back("CEF_TR");
      }
    }

    if ((version_ == WINTER17 || version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI ||
         version_ == RUN2UL16CHS || version_ == RUN2UL16PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI) &&
        quality_ == LOOSE) {
      edm::LogWarning("BadJetIDVersion")
          << "The LOOSE operating point is only supported for the WINTER16 JetID version -- defaulting to TIGHT";
      quality_ = TIGHT;
    }

    // Set some default cuts for LOOSE, TIGHT
    if (quality_ == LOOSE) {
      set("CHF", 0.0);
      set("NHF", 0.99);
      set("CEF", 0.99);
      set("NEF", 0.99);
      set("NCH", 0);
      set("nConstituents", 1);
      if (version_ == RUNIISTARTUP) {
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == WINTER16) {
        set("NHF_EC", 0.98);
        set("NEF_EC", 0.01);
        set("nNeutrals_EC", 2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      }
    } else if (quality_ == TIGHT) {
      set("CHF", 0.0);
      set("NHF", 0.9);
      if (version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
          version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI)
        set("CEF", 0.99);
      set("NEF", 0.9);
      set("NCH", 0);
      set("nConstituents", 1);
      if (version_ == RUNIISTARTUP) {
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == WINTER16) {
        set("NHF_EC", 0.98);
        set("NEF_EC", 0.01);
        set("nNeutrals_EC", 2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == WINTER17) {
        set("NEF_EC_L", 0.02);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == WINTER17PUPPI) {
        set("NHF_EC", 0.99);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 15);
      } else if (version_ == SUMMER18) {
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NCH_TR", 0);
        set("NEF_EC_L", 0.02);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == SUMMER18PUPPI) {
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NHF_EC", 0.99);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 15);
      } else if (version_ == RUN2UL16CHS) {
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NHF_EC", 0.9);
        set("NEF_EC_L", 0.);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 1);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == RUN2UL16PUPPI) {
        set("NHF_TR", 0.98);
        set("NEF_TR", 0.99);
        set("nNeutrals_EC", 1);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 999999);
      } else if (version_ == RUN2ULCHS) {
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NCH_TR", 0);
        set("NEF_EC_L", 0.01);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == RUN2ULPUPPI) {
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NHF_EC", 0.9999);
        set("NHF_FW", -1.0);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 999999);
      }
    } else if (quality_ == TIGHTLEPVETO) {
      set("CHF", 0.0);
      set("NHF", 0.9);
      set("NEF", 0.9);
      set("NCH", 0);
      set("nConstituents", 1);
      if (version_ == WINTER17) {
        set("CEF", 0.8);
        set("NEF_EC_L", 0.02);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
        set("MUF", 0.8);
      } else if (version_ == WINTER17PUPPI) {
        set("CEF", 0.8);
        set("NHF_EC", 0.99);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 15);
        set("MUF", 0.8);
      } else if (version_ == WINTER16) {
        set("CEF", 0.9);
        set("NEF_EC", 0.01);
        set("NHF_EC", 0.98);
        set("nNeutrals_EC", 2);
        set("nNeutrals_FW", 10);
        set("NEF_FW", 0.90);
        set("MUF", 0.8);
      } else if (version_ == WINTER17PUPPI) {
        set("CEF", 0.8);
        set("NHF_EC", 0.99);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 15);
        set("MUF", 0.8);
      } else if (version_ == WINTER16) {
        set("CEF", 0.9);
        set("NEF_EC", 0.01);
        set("NHF_EC", 0.98);
        set("nNeutrals_EC", 2);
        set("nNeutrals_FW", 10);
        set("NEF_FW", 0.90);
        set("MUF", 0.8);
      } else if (version_ == SUMMER18) {
        set("CEF", 0.8);
        set("MUF", 0.8);
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("MUF_TR", 0.8);
        set("NCH_TR", 0);
        set("CEF_TR", 0.8);
        set("NEF_EC_L", 0.02);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == SUMMER18PUPPI) {
        set("CEF", 0.8);
        set("MUF", 0.8);
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("MUF_TR", 0.8);
        set("CEF_TR", 0.8);
        set("NHF_EC", 0.99);
        set("NHF_FW", 0.02);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 15);
      } else if (version_ == RUN2UL16CHS) {
        set("MUF", 0.8);
        set("CEF", 0.8);
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("NHF_EC", 0.9);
        set("NEF_EC_L", 0.);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 1);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == RUN2UL16PUPPI) {
        set("MUF", 0.8);
        set("CEF", 0.8);
        set("NHF_TR", 0.98);
        set("NEF_TR", 0.99);
        set("nNeutrals_EC", 1);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 999999);
      } else if (version_ == RUN2ULCHS) {
        set("CEF", 0.8);
        set("MUF", 0.8);
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("MUF_TR", 0.8);
        set("NCH_TR", 0);
        set("CEF_TR", 0.8);
        set("NEF_EC_L", 0.01);
        set("NEF_EC_U", 0.99);
        set("nNeutrals_EC", 2);
        set("NHF_FW", 0.2);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW", 10);
      } else if (version_ == RUN2ULPUPPI) {
        set("CEF", 0.8);
        set("MUF", 0.8);
        set("NHF_TR", 0.9);
        set("NEF_TR", 0.99);
        set("MUF_TR", 0.8);
        set("CEF_TR", 0.8);
        set("NHF_EC", 0.9999);
        set("NHF_FW", -1.0);
        set("NEF_FW", 0.90);
        set("nNeutrals_FW_L", 2);
        set("nNeutrals_FW_U", 999999);
      }
    }
  }

void PFJetIDSelectionFunctor::initIndex ( )

inlineprivate

Definition at line 1095 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, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by PFJetIDSelectionFunctor().

                   {
    indexNConstituents_ = index_type(&bits_, "nConstituents");
    indexNEF_ = index_type(&bits_, "NEF");
    indexNHF_ = index_type(&bits_, "NHF");
    if ((version_ != WINTER17 && version_ != WINTER17PUPPI && version_ != SUMMER18 && version_ != SUMMER18PUPPI &&
         version_ != RUN2UL16CHS && version_ != RUN2UL16PUPPI && version_ != RUN2ULCHS && version_ != RUN2ULPUPPI) ||
        quality_ != TIGHT)
      indexCEF_ = index_type(&bits_, "CEF");

    indexCHF_ = index_type(&bits_, "CHF");
    indexNCH_ = index_type(&bits_, "NCH");
    if (version_ == RUNIISTARTUP) {
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
    }
    if (version_ == WINTER16) {
      indexNHF_EC_ = index_type(&bits_, "NHF_EC");
      indexNEF_EC_ = index_type(&bits_, "NEF_EC");
      indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
      }
    }
    if (version_ == WINTER17) {
      indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
      indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
      indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
      indexNHF_FW_ = index_type(&bits_, "NHF_FW");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
      }
    }
    if (version_ == WINTER17PUPPI) {
      indexNHF_EC_ = index_type(&bits_, "NHF_EC");
      indexNHF_FW_ = index_type(&bits_, "NHF_FW");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
      indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
      }
    }
    if ((version_ == SUMMER18) || (version_ == RUN2ULCHS)) {
      indexNHF_TR_ = index_type(&bits_, "NHF_TR");
      indexNEF_TR_ = index_type(&bits_, "NEF_TR");
      indexNCH_TR_ = index_type(&bits_, "NCH_TR");
      indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
      indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
      indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
      indexNHF_FW_ = index_type(&bits_, "NHF_FW");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
        indexMUF_TR_ = index_type(&bits_, "MUF_TR");
        indexCEF_TR_ = index_type(&bits_, "CEF_TR");
      }
    }
    if ((version_ == SUMMER18PUPPI) || (version_ == RUN2ULPUPPI)) {
      indexNHF_TR_ = index_type(&bits_, "NHF_TR");
      indexNEF_TR_ = index_type(&bits_, "NEF_TR");
      indexNHF_EC_ = index_type(&bits_, "NHF_EC");
      indexNHF_FW_ = index_type(&bits_, "NHF_FW");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
      indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
        indexMUF_TR_ = index_type(&bits_, "MUF_TR");
        indexCEF_TR_ = index_type(&bits_, "CEF_TR");
      }
    }
    if (version_ == RUN2UL16CHS) {
      indexNHF_TR_ = index_type(&bits_, "NHF_TR");
      indexNEF_TR_ = index_type(&bits_, "NEF_TR");
      indexNHF_EC_ = index_type(&bits_, "NHF_EC");
      indexNEF_EC_L_ = index_type(&bits_, "NEF_EC_L");
      indexNEF_EC_U_ = index_type(&bits_, "NEF_EC_U");
      indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
      indexNHF_FW_ = index_type(&bits_, "NHF_FW");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_ = index_type(&bits_, "nNeutrals_FW");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
      }
    }
    if (version_ == RUN2UL16PUPPI) {
      indexNHF_TR_ = index_type(&bits_, "NHF_TR");
      indexNEF_TR_ = index_type(&bits_, "NEF_TR");
      indexNNeutrals_EC_ = index_type(&bits_, "nNeutrals_EC");
      indexNEF_FW_ = index_type(&bits_, "NEF_FW");
      indexNNeutrals_FW_L_ = index_type(&bits_, "nNeutrals_FW_L");
      indexNNeutrals_FW_U_ = index_type(&bits_, "nNeutrals_FW_U");
      if (quality_ == TIGHTLEPVETO) {
        indexMUF_ = index_type(&bits_, "MUF");
      }
    }
    retInternal_ = getBitTemplate();
  }

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 272 of file PFJetIDSelectionFunctor.h.

References pat::Jet::correctedJet(), pat::Jet::currentJECLevel(), FIRSTDATA, firstDataCuts(), pat::Jet::jecSetsAvailable(), runTheMatrix::ret, RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by operator()().

                                                                 {
    if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
        version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2UL16CHS ||
        version_ == RUN2UL16PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI) {
      if (jet.currentJECLevel() == "Uncorrected" || !jet.jecSetsAvailable())
        return firstDataCuts(jet, ret, version_);
      else
        return firstDataCuts(jet.correctedJet("Uncorrected"), ret, version_);
    } else {
      return false;
    }
  }

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

inline

Definition at line 290 of file PFJetIDSelectionFunctor.h.

References FIRSTDATA, firstDataCuts(), RUN2UL16CHS, RUN2UL16PUPPI, RUN2ULCHS, RUN2ULPUPPI, RUNIISTARTUP, SUMMER18, SUMMER18PUPPI, version_, WINTER16, WINTER17, and WINTER17PUPPI.

                                                           {
    if (version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 ||
        version_ == WINTER17PUPPI || version_ == SUMMER18 || version_ == SUMMER18PUPPI || version_ == RUN2UL16CHS ||
        version_ == RUN2UL16PUPPI || version_ == RUN2ULCHS || version_ == RUN2ULPUPPI) {
      return firstDataCuts(jet, ret, version_);
    } else {
      return false;
    }
  }

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

inline

Definition at line 300 of file PFJetIDSelectionFunctor.h.

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

                                        {
    retInternal_.set(false);
    operator()(jet, retInternal_);
    setIgnored(retInternal_);
    return (bool)retInternal_;
  }

Member Data Documentation

index_type PFJetIDSelectionFunctor::indexCEF_

private

Definition at line 1206 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexCEF_TR_

private

Definition at line 1214 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexCHF_

private

Definition at line 1207 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexMUF_

private

Definition at line 1204 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexMUF_TR_

private

Definition at line 1213 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNCH_

private

Definition at line 1208 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNCH_TR_

private

Definition at line 1212 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNConstituents_

private

Definition at line 1202 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_

private

Definition at line 1203 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_

private

Definition at line 1223 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_L_

private

Definition at line 1224 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_U_

private

Definition at line 1225 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_FW_

private

Definition at line 1217 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_TR_

private

Definition at line 1211 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_

private

Definition at line 1205 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_EC_

private

Definition at line 1222 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_FW_

private

Definition at line 1216 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_TR_

private

Definition at line 1210 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_EC_

private

Definition at line 1226 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_

private

Definition at line 1218 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_L_

private

Definition at line 1219 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_U_

private

Definition at line 1220 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

Quality_t PFJetIDSelectionFunctor::quality_

private

Definition at line 1200 of file PFJetIDSelectionFunctor.h.

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

Version_t PFJetIDSelectionFunctor::version_

private

Definition at line 1199 of file PFJetIDSelectionFunctor.h.

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