#include <PFJetMETcorrInputProducerT.h>

Inheritance diagram for PFJetMETcorrInputProducerT< T, Textractor >:

Classes
struct	type2BinningEntryType

Public Member Functions
	PFJetMETcorrInputProducerT (const edm::ParameterSet &cfg)

	~PFJetMETcorrInputProducerT () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	produce (edm::Event &evt, const edm::EventSetup &es) override

Private Attributes
double	jetCorrEtaMax_

Textractor	jetCorrExtractor_

edm::InputTag	jetCorrLabel_

edm::InputTag	jetCorrLabelRes_

edm::EDGetTokenT< reco::JetCorrector >	jetCorrResToken_

edm::EDGetTokenT< reco::JetCorrector >	jetCorrToken_

std::string	moduleLabel_

edm::InputTag	offsetCorrLabel_

edm::EDGetTokenT< reco::JetCorrector >	offsetCorrToken_

bool	skipEM_

double	skipEMfractionThreshold_

bool	skipMuons_

StringCutObjectSelector< reco::Candidate > *	skipMuonSelection_

edm::EDGetTokenT< std::vector< T > >	token_

double	type1JetPtThreshold_

std::vector< type2BinningEntryType * >	type2Binning_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename T, typename Textractor>
class PFJetMETcorrInputProducerT< T, Textractor >

Produce Type 1 + 2 MET corrections corresponding to differences between raw PFJets and PFJets with jet energy corrections (JECs) applied

NOTE: class is templated to that it works with reco::PFJets as well as with pat::Jets of PF-type as input

Authors: Michael Schmitt, Richard Cavanaugh, The University of Florida Florent Lacroix, University of Illinois at Chicago Christian Veelken, LLR

Definition at line 77 of file PFJetMETcorrInputProducerT.h.

Constructor & Destructor Documentation

◆ PFJetMETcorrInputProducerT()

template<typename T , typename Textractor >

PFJetMETcorrInputProducerT< T, Textractor >::PFJetMETcorrInputProducerT ( const edm::ParameterSet & cfg )

inlineexplicit

Definition at line 79 of file PFJetMETcorrInputProducerT.h.

       : moduleLabel_(cfg.getParameter<std::string>("@module_label")),
         offsetCorrLabel_(""),
         skipMuonSelection_(nullptr) {
     token_ = consumes<std::vector<T> >(cfg.getParameter<edm::InputTag>("src"));
 
     if (cfg.exists("offsetCorrLabel")) {
       offsetCorrLabel_ = cfg.getParameter<edm::InputTag>("offsetCorrLabel");
       offsetCorrToken_ = consumes<reco::JetCorrector>(offsetCorrLabel_);
     }
     jetCorrLabel_ = cfg.getParameter<edm::InputTag>("jetCorrLabel");        //for MC
     jetCorrLabelRes_ = cfg.getParameter<edm::InputTag>("jetCorrLabelRes");  //for data
     jetCorrToken_ = mayConsume<reco::JetCorrector>(jetCorrLabel_);
     jetCorrResToken_ = mayConsume<reco::JetCorrector>(jetCorrLabelRes_);
 
     jetCorrEtaMax_ = (cfg.exists("jetCorrEtaMax")) ? cfg.getParameter<double>("jetCorrEtaMax") : 9.9;
 
     type1JetPtThreshold_ = cfg.getParameter<double>("type1JetPtThreshold");
 
     skipEM_ = cfg.getParameter<bool>("skipEM");
     if (skipEM_) {
       skipEMfractionThreshold_ = cfg.getParameter<double>("skipEMfractionThreshold");
     }
 
     skipMuons_ = cfg.getParameter<bool>("skipMuons");
     if (skipMuons_) {
       std::string skipMuonSelection_string = cfg.getParameter<std::string>("skipMuonSelection");
       skipMuonSelection_ = new StringCutObjectSelector<reco::Candidate>(skipMuonSelection_string, true);
     }
 
     if (cfg.exists("type2Binning")) {
       typedef std::vector<edm::ParameterSet> vParameterSet;
       vParameterSet cfgType2Binning = cfg.getParameter<vParameterSet>("type2Binning");
       for (vParameterSet::const_iterator cfgType2BinningEntry = cfgType2Binning.begin();
            cfgType2BinningEntry != cfgType2Binning.end();
            ++cfgType2BinningEntry) {
         type2Binning_.push_back(new type2BinningEntryType(*cfgType2BinningEntry));
       }
     } else {
       type2Binning_.push_back(new type2BinningEntryType());
     }
 
     produces<CorrMETData>("type1");
     for (typename std::vector<type2BinningEntryType*>::const_iterator type2BinningEntry = type2Binning_.begin();
          type2BinningEntry != type2Binning_.end();
          ++type2BinningEntry) {
       produces<CorrMETData>((*type2BinningEntry)->getInstanceLabel_full("type2"));
       produces<CorrMETData>((*type2BinningEntry)->getInstanceLabel_full("offset"));
     }
   }

◆ ~PFJetMETcorrInputProducerT()

template<typename T , typename Textractor >

PFJetMETcorrInputProducerT< T, Textractor >::~PFJetMETcorrInputProducerT ( )

inlineoverride

Definition at line 129 of file PFJetMETcorrInputProducerT.h.

References PFJetMETcorrInputProducerT< T, Textractor >::skipMuonSelection_, and PFJetMETcorrInputProducerT< T, Textractor >::type2Binning_.

                                          {
     delete skipMuonSelection_;
 
     for (typename std::vector<type2BinningEntryType*>::const_iterator it = type2Binning_.begin();
          it != type2Binning_.end();
          ++it) {
       delete (*it);
     }
   }

Member Function Documentation

◆ fillDescriptions()

template<typename T , typename Textractor >

static void PFJetMETcorrInputProducerT< T, Textractor >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 139 of file PFJetMETcorrInputProducerT.h.

References edm::ConfigurationDescriptions::add(), defaultModuleLabel(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src", edm::InputTag("ak4PFJetsCHS"));
     desc.add<edm::InputTag>("offsetCorrLabel", edm::InputTag("ak4PFCHSL1FastjetCorrector"));
     desc.add<edm::InputTag>("jetCorrLabel", edm::InputTag("ak4PFCHSL1FastL2L3Corrector"));
     desc.add<edm::InputTag>("jetCorrLabelRes", edm::InputTag("ak4PFCHSL1FastL2L3ResidualCorrector"));
     desc.add<double>("jetCorrEtaMax", 9.9);
     desc.add<double>("type1JetPtThreshold", 15);
     desc.add<bool>("skipEM", true);
     desc.add<double>("skipEMfractionThreshold", 0.90);
     desc.add<bool>("skipMuons", true);
     desc.add<std::string>("skipMuonSelection", "isGlobalMuon | isStandAloneMuon");
     descriptions.add(defaultModuleLabel<PFJetMETcorrInputProducerT<T, Textractor> >(), desc);
   }

◆ produce()

template<typename T , typename Textractor >

void PFJetMETcorrInputProducerT< T, Textractor >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

inlineoverrideprivate

Definition at line 155 of file PFJetMETcorrInputProducerT.h.

                                                                 {
     std::unique_ptr<CorrMETData> type1Correction(new CorrMETData());
     for (typename std::vector<type2BinningEntryType*>::iterator type2BinningEntry = type2Binning_.begin();
          type2BinningEntry != type2Binning_.end();
          ++type2BinningEntry) {
       (*type2BinningEntry)->binUnclEnergySum_ = CorrMETData();
       (*type2BinningEntry)->binOffsetEnergySum_ = CorrMETData();
     }
 
     edm::Handle<reco::JetCorrector> jetCorr;
     //automatic switch for residual corrections
     if (evt.isRealData()) {
       jetCorrLabel_ = jetCorrLabelRes_;
       evt.getByToken(jetCorrResToken_, jetCorr);
     } else {
       evt.getByToken(jetCorrToken_, jetCorr);
     }
 
     typedef std::vector<T> JetCollection;
     edm::Handle<JetCollection> jets;
     evt.getByToken(token_, jets);
 
     int numJets = jets->size();
     for (int jetIndex = 0; jetIndex < numJets; ++jetIndex) {
       const T& jet = jets->at(jetIndex);
 
       const static PFJetMETcorrInputProducer_namespace::InputTypeCheckerT<T, Textractor> checkInputType{};
       checkInputType(jet);
 
       double emEnergyFraction = jet.chargedEmEnergyFraction() + jet.neutralEmEnergyFraction();
       if (skipEM_ && emEnergyFraction > skipEMfractionThreshold_)
         continue;
 
       const static PFJetMETcorrInputProducer_namespace::RawJetExtractorT<T> rawJetExtractor{};
       reco::Candidate::LorentzVector rawJetP4 = rawJetExtractor(jet);
 
       if (skipMuons_) {
         const std::vector<reco::CandidatePtr>& cands = jet.daughterPtrVector();
         for (std::vector<reco::CandidatePtr>::const_iterator cand = cands.begin(); cand != cands.end(); ++cand) {
           const reco::PFCandidate* pfcand = dynamic_cast<const reco::PFCandidate*>(cand->get());
           const reco::Candidate* mu =
               (pfcand != nullptr ? (pfcand->muonRef().isNonnull() ? pfcand->muonRef().get() : nullptr) : cand->get());
           if (mu != nullptr && (*skipMuonSelection_)(*mu)) {
             reco::Candidate::LorentzVector muonP4 = (*cand)->p4();
             rawJetP4 -= muonP4;
           }
         }
       }
 
       reco::Candidate::LorentzVector corrJetP4;
       if (checkInputType.isPatJet(jet))
         corrJetP4 = jetCorrExtractor_(jet, jetCorrLabel_.label(), jetCorrEtaMax_, &rawJetP4);
       else
         corrJetP4 = jetCorrExtractor_(jet, jetCorr.product(), jetCorrEtaMax_, &rawJetP4);
       // retrieve additional jet energy scales in case of pat::Jets (done via specialized template defined for pat::Jets) and apply them
       const static PFJetMETcorrInputProducer_namespace::AdditionalScalesT<T> additionalScales{};
       corrJetP4 *= additionalScales(jet);
 
       if (corrJetP4.pt() > type1JetPtThreshold_) {
         reco::Candidate::LorentzVector rawJetP4offsetCorr = rawJetP4;
         if (!offsetCorrLabel_.label().empty()) {
           edm::Handle<reco::JetCorrector> offsetCorr;
           evt.getByToken(offsetCorrToken_, offsetCorr);
           if (checkInputType.isPatJet(jet))
             rawJetP4offsetCorr = jetCorrExtractor_(jet, offsetCorrLabel_.label(), jetCorrEtaMax_, &rawJetP4);
           else
             rawJetP4offsetCorr = jetCorrExtractor_(jet, offsetCorr.product(), jetCorrEtaMax_, &rawJetP4);
 
           for (typename std::vector<type2BinningEntryType*>::iterator type2BinningEntry = type2Binning_.begin();
                type2BinningEntry != type2Binning_.end();
                ++type2BinningEntry) {
             if (!(*type2BinningEntry)->binSelection_ || (*(*type2BinningEntry)->binSelection_)(corrJetP4)) {
               (*type2BinningEntry)->binOffsetEnergySum_.mex += (rawJetP4.px() - rawJetP4offsetCorr.px());
               (*type2BinningEntry)->binOffsetEnergySum_.mey += (rawJetP4.py() - rawJetP4offsetCorr.py());
               (*type2BinningEntry)->binOffsetEnergySum_.sumet += (rawJetP4.Et() - rawJetP4offsetCorr.Et());
             }
           }
         }
 
         //--- MET balances momentum of reconstructed particles,
         //    hence correction to jets and corresponding Type 1 MET correction are of opposite sign
         type1Correction->mex -= (corrJetP4.px() - rawJetP4offsetCorr.px());
         type1Correction->mey -= (corrJetP4.py() - rawJetP4offsetCorr.py());
         type1Correction->sumet += (corrJetP4.Et() - rawJetP4offsetCorr.Et());
       } else {
         for (typename std::vector<type2BinningEntryType*>::iterator type2BinningEntry = type2Binning_.begin();
              type2BinningEntry != type2Binning_.end();
              ++type2BinningEntry) {
           if (!(*type2BinningEntry)->binSelection_ || (*(*type2BinningEntry)->binSelection_)(corrJetP4)) {
             (*type2BinningEntry)->binUnclEnergySum_.mex += rawJetP4.px();
             (*type2BinningEntry)->binUnclEnergySum_.mey += rawJetP4.py();
             (*type2BinningEntry)->binUnclEnergySum_.sumet += rawJetP4.Et();
           }
         }
       }
     }
 
     //--- add
     //     o Type 1 MET correction                (difference corrected-uncorrected jet energy for jets of (corrected) Pt > 10 GeV)
     //     o momentum sum of "unclustered energy" (jets of (corrected) Pt < 10 GeV)
     //     o momentum sum of "offset energy"      (sum of energy attributed to pile-up/underlying event)
     //    to the event
     evt.put(std::move(type1Correction), "type1");
     for (typename std::vector<type2BinningEntryType*>::const_iterator type2BinningEntry = type2Binning_.begin();
          type2BinningEntry != type2Binning_.end();
          ++type2BinningEntry) {
       evt.put(std::unique_ptr<CorrMETData>(new CorrMETData((*type2BinningEntry)->binUnclEnergySum_)),
               (*type2BinningEntry)->getInstanceLabel_full("type2"));
       evt.put(std::unique_ptr<CorrMETData>(new CorrMETData((*type2BinningEntry)->binOffsetEnergySum_)),
               (*type2BinningEntry)->getInstanceLabel_full("offset"));
     }
   }