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, N_VERSIONS }
Public Types inherited from Selector< pat::Jet >
typedef std::binary_function< pat::Jet, pat::strbitset, bool >	base_type
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
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, pat::strbitset &ret)=0
	This provides the interface for base classes to select objects. More...
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 ()

Private Member Functions
void	initCuts ()
void	initIndex ()

Private Attributes
index_type	indexCEF_
index_type	indexCHF_
index_type	indexMUF_
index_type	indexNCH_
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	indexNHF_
index_type	indexNHF_EC_
index_type	indexNHF_FW_
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 24 of file PFJetIDSelectionFunctor.h.

Member Enumeration Documentation

enum PFJetIDSelectionFunctor::Quality_t

Enumerator
LOOSE
TIGHT
TIGHTLEPVETO
N_QUALITY

Definition at line 29 of file PFJetIDSelectionFunctor.h.

{ LOOSE, TIGHT, TIGHTLEPVETO, N_QUALITY};

enum PFJetIDSelectionFunctor::Version_t

Enumerator
FIRSTDATA
RUNIISTARTUP
WINTER16
WINTER17
WINTER17PUPPI
N_VERSIONS

Definition at line 28 of file PFJetIDSelectionFunctor.h.

{ FIRSTDATA, RUNIISTARTUP, WINTER16, WINTER17, WINTER17PUPPI, N_VERSIONS };

Constructor & Destructor Documentation

PFJetIDSelectionFunctor::PFJetIDSelectionFunctor ( )

inline

Definition at line 31 of file PFJetIDSelectionFunctor.h.

{}

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

inline

Definition at line 34 of file PFJetIDSelectionFunctor.h.

                                                                                      :
    PFJetIDSelectionFunctor(params)
  {}

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

inline

Definition at line 39 of file PFJetIDSelectionFunctor.h.

References edm::ParameterSet::exists(), FIRSTDATA, edm::ParameterSet::getParameter(), initCuts(), initIndex(), LOOSE, quality_, RUNIISTARTUP, Selector< pat::Jet >::setIgnoredCuts(), AlCaHLTBitMon_QueryRunRegistry::string, 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;  
   // WINTER16 implements most recent (as of Feb 2017) JetID criteria
   // See: https://twiki.cern.ch/twiki/bin/view/CMS/JetID13TeVRun2016
   else if( versionStr == "WINTER16") 
     version_ = WINTER16; 
   else if( versionStr == "WINTER17") 
     version_ = WINTER17;   
   else if( versionStr == "WINTER17PUPPI")
     version_ = WINTER17PUPPI;
   else version_ = WINTER17;//set WINTER17 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) || 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<int> ("NHF_EC") );
      if ( params.exists("NEF_EC") ) set("NEF_EC", params.getParameter<int> ("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(version_ == WINTER17){
      if ( params.exists("NEF_EC_L") ) set("NEF_EC_L", params.getParameter<int> ("NEF_EC_L") );
      if ( params.exists("NEF_EC_U") ) set("NEF_EC_U", params.getParameter<int> ("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<int> ("MUF") );}
    }
    if(version_ == WINTER17PUPPI){
      if ( params.exists("NHF_EC") ) set("NHF_EC", params.getParameter<int> ("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<int> ("MUF") );}
    }


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

References funct::abs(), 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(), reco::LeafCandidate::eta(), FIRSTDATA, pat::PATObject< ObjectType >::hasUserFloat(), reco::PFJet::HFEMEnergy(), Selector< pat::Jet >::ignoreCut(), indexCEF_, indexCHF_, indexMUF_, indexNCH_, indexNConstituents_, indexNEF_, indexNEF_EC_, indexNEF_EC_L_, indexNEF_EC_U_, indexNEF_FW_, indexNHF_, indexNHF_EC_, indexNHF_FW_, indexNNeutrals_EC_, indexNNeutrals_FW_, indexNNeutrals_FW_L_, indexNNeutrals_FW_U_, pat::Jet::isBasicJet(), pat::Jet::isPFJet(), metsig::jet, reco::PFJet::muonEnergy(), reco::PFJet::neutralEmEnergy(), pat::Jet::neutralEmEnergy(), pat::Jet::neutralEmEnergyFraction(), reco::PFJet::neutralHadronEnergy(), pat::Jet::neutralHadronEnergy(), pat::Jet::neutralHadronEnergyFraction(), reco::PFJet::neutralMultiplicity(), pat::Jet::neutralMultiplicity(), reco::CompositePtrCandidate::numberOfDaughters(), pat::Jet::numberOfDaughters(), Selector< pat::Jet >::passCut(), reco::PFJet::photonEnergy(), quality_, RUNIISTARTUP, pat::strbitset::set(), Selector< pat::Jet >::setIgnored(), TIGHT, TIGHTLEPVETO, pat::PATObject< ObjectType >::userFloat(), 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();
    nconstituents = patJet->numberOfDaughters();
    nneutrals = patJet->neutralMultiplicity();
        // Handle the special case of PUPPI jets with weighted multiplicities
        if (patJet->hasUserFloat("patPuppiJetSpecificProducer:puppiMultiplicity"))
           nconstituents = patJet->userFloat("patPuppiJetSpecificProducer:puppiMultiplicity");
        if (patJet->hasUserFloat("patPuppiJetSpecificProducer:neutralPuppiMultiplicity"))
           nneutrals = patJet->userFloat("patPuppiJetSpecificProducer:neutralPuppiMultiplicity");
      }
      // 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;
    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();
        nch += patsub->chargedMultiplicity();
            nconstituents += patsub->numberOfDaughters();
        nneutrals += patsub->neutralMultiplicity();
      } else if ( pfsub ) {
            e_chf += pfsub->chargedHadronEnergy();
        e_nhf += pfsub->neutralHadronEnergy();
        e_cef += pfsub->chargedEmEnergy();
        e_nef += pfsub->neutralEmEnergy();
        nch += pfsub->chargedMultiplicity();
            nconstituents += pfsub->numberOfDaughters();
        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;
    } else {
      chf = nhf = cef = nef = 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->numberOfDaughters();
      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;
      nch = 0;
      nconstituents = 0;
      for ( reco::Jet::const_iterator ibegin = basicJet->begin(),
          iend = patJet->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();
    nch += pfsub->chargedMultiplicity();
    nconstituents += pfsub->numberOfDaughters();
    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;
      }
    } // end if basic jet



   // Cuts for |eta| < 2.4 for FIRSTDATA, RUNIISTARTUP, WINTER16 and WINTER17
    if((version_ != WINTER17 && version_ != WINTER17PUPPI) ||  quality_ != TIGHT ) {if ( ignoreCut(indexCEF_)           || ( cef < cut(indexCEF_, double()) || std::abs(jet.eta()) > 2.4 ) ) passCut( ret, indexCEF_);}

    if ( ignoreCut(indexCHF_)           || ( chf > cut(indexCHF_, double()) || std::abs(jet.eta()) > 2.4 ) ) passCut( ret, indexCHF_);
    if ( ignoreCut(indexNCH_)           || ( nch > cut(indexNCH_, int())    || std::abs(jet.eta()) > 2.4 ) ) 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_);

      // 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_);

    }


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

References LOOSE, Selector< pat::Jet >::push_back(), quality_, RUNIISTARTUP, TIGHT, TIGHTLEPVETO, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by PFJetIDSelectionFunctor().

  {
    push_back("CHF" );
    push_back("NHF" );
    if( (version_ != WINTER17 && version_!=WINTER17PUPPI) || 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(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_ == WINTER17 || version_ == WINTER17PUPPI) && quality_ == LOOSE ){
      edm::LogWarning("BadJetIDVersion") << "Winter17 JetID version does not support the LOOSE operating point -- defaulting to TIGHT";
      quality_ = TIGHT;
      }

   if( (version_ != WINTER17 && version_ != WINTER17PUPPI) && quality_ ==  TIGHTLEPVETO){
      edm::LogWarning("BadJetIDVersion") << "JetID version does not support the TIGHTLEPVETO operating point -- 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);
      }
      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 ) 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);
      }
      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);
      }
      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);
      }
      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 ( quality_ == TIGHTLEPVETO ) {
      set("CHF", 0.0);
      set("NHF", 0.9);
      set("CEF", 0.8);
      set("NEF", 0.9);
      set("NCH", 0);
      set("nConstituents", 1);
      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);
        set("MUF", 0.8);
      }
      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);
        set("MUF", 0.8);
      }

    }
  }

void PFJetIDSelectionFunctor::initIndex ( )

inlineprivate

Definition at line 508 of file PFJetIDSelectionFunctor.h.

References Selector< pat::Jet >::bits_, Selector< pat::Jet >::getBitTemplate(), indexCEF_, indexCHF_, indexMUF_, indexNCH_, indexNConstituents_, indexNEF_, indexNEF_EC_, indexNEF_EC_L_, indexNEF_EC_U_, indexNEF_FW_, indexNHF_, indexNHF_EC_, indexNHF_FW_, indexNNeutrals_EC_, indexNNeutrals_FW_, indexNNeutrals_FW_L_, indexNNeutrals_FW_U_, quality_, Selector< pat::Jet >::retInternal_, RUNIISTARTUP, 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) || 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(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");}
    }

    retInternal_ = getBitTemplate();
  }

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

inlineoverride

Definition at line 123 of file PFJetIDSelectionFunctor.h.

References pat::Jet::correctedJet(), pat::Jet::currentJECLevel(), FIRSTDATA, firstDataCuts(), pat::Jet::jecSetsAvailable(), Utilities::operator, RUNIISTARTUP, version_, WINTER16, WINTER17, and WINTER17PUPPI.

Referenced by operator()().

  {
    if ( version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 || version_ == WINTER17PUPPI) {
      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 141 of file PFJetIDSelectionFunctor.h.

References FIRSTDATA, firstDataCuts(), RUNIISTARTUP, version_, WINTER16, WINTER17, and WINTER17PUPPI.

  {
    if ( version_ == FIRSTDATA || version_ == RUNIISTARTUP || version_ == WINTER16 || version_ == WINTER17 || version_ == WINTER17PUPPI  ){ return firstDataCuts( jet, ret, version_);
    }
    else {
      return false;
    }
  }

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

inline

Definition at line 150 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 556 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexCHF_

private

Definition at line 557 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexMUF_

private

Definition at line 554 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNCH_

private

Definition at line 558 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNConstituents_

private

Definition at line 552 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_

private

Definition at line 553 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_

private

Definition at line 567 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_L_

private

Definition at line 568 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_EC_U_

private

Definition at line 569 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNEF_FW_

private

Definition at line 561 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_

private

Definition at line 555 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_EC_

private

Definition at line 566 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNHF_FW_

private

Definition at line 560 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_EC_

private

Definition at line 570 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_

private

Definition at line 562 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_L_

private

Definition at line 563 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

index_type PFJetIDSelectionFunctor::indexNNeutrals_FW_U_

private

Definition at line 564 of file PFJetIDSelectionFunctor.h.

Referenced by firstDataCuts(), and initIndex().

Quality_t PFJetIDSelectionFunctor::quality_

private

Definition at line 550 of file PFJetIDSelectionFunctor.h.

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

Version_t PFJetIDSelectionFunctor::version_

private

Definition at line 549 of file PFJetIDSelectionFunctor.h.

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