#include <ShiftedJetProducerT.h>

Inheritance diagram for ShiftedJetProducerT< T, Textractor >:

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

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

Private Types
typedef std::vector< T >	JetCollection

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

Private Attributes
bool	addResidualJES_

std::unique_ptr< JetCorrectionUncertainty >	jecUncertainty_

double	jecUncertaintyValue_

double	jetCorrEtaMax_

Textractor	jetCorrExtractor_

edm::FileInPath	jetCorrInputFileName_

edm::InputTag	jetCorrLabelUpToL3_

edm::InputTag	jetCorrLabelUpToL3Res_

std::unique_ptr< JetCorrectorParameters >	jetCorrParameters_

std::string	jetCorrPayloadName_

edm::ESGetToken< JetCorrectorParametersCollection, JetCorrectionsRecord >	jetCorrPayloadToken_

edm::EDGetTokenT< reco::JetCorrector >	jetCorrTokenUpToL3_

edm::EDGetTokenT< reco::JetCorrector >	jetCorrTokenUpToL3Res_

std::string	jetCorrUncertaintyTag_

std::string	moduleLabel_

double	shiftBy_

edm::InputTag	src_

edm::EDGetTokenT< JetCollection >	srcToken_

int	verbosity_

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 ShiftedJetProducerT< T, Textractor >

Vary energy of jets by +/- 1 standard deviation, in order to estimate resulting uncertainty on MET

NOTE: energy scale uncertainties are taken from the Database

Author: Christian Veelken, LLR

Definition at line 37 of file ShiftedJetProducerT.h.

Member Typedef Documentation

◆ JetCollection

template<typename T , typename Textractor >

typedef std::vector<T> ShiftedJetProducerT< T, Textractor >::JetCollection

private

Definition at line 38 of file ShiftedJetProducerT.h.

Constructor & Destructor Documentation

◆ ShiftedJetProducerT()

template<typename T , typename Textractor >

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

inlineexplicit

Definition at line 41 of file ShiftedJetProducerT.h.

       : moduleLabel_(cfg.getParameter<std::string>("@module_label")),
         src_(cfg.getParameter<edm::InputTag>("src")),
         srcToken_(consumes<JetCollection>(src_)),
         jetCorrPayloadName_(""),
         jetCorrParameters_(nullptr),
         jecUncertainty_(nullptr),
         jecUncertaintyValue_(-1.) {
     if (cfg.exists("jecUncertaintyValue")) {
       jecUncertaintyValue_ = cfg.getParameter<double>("jecUncertaintyValue");
     } else {
       jetCorrUncertaintyTag_ = cfg.getParameter<std::string>("jetCorrUncertaintyTag");
       if (cfg.exists("jetCorrInputFileName")) {
         jetCorrInputFileName_ = cfg.getParameter<edm::FileInPath>("jetCorrInputFileName");
         if (jetCorrInputFileName_.location() == edm::FileInPath::Unknown)
           throw cms::Exception("ShiftedJetProducerT")
               << " Failed to find JEC parameter file = " << jetCorrInputFileName_ << " !!\n";
         jetCorrParameters_ =
             std::make_unique<JetCorrectorParameters>(jetCorrInputFileName_.fullPath(), jetCorrUncertaintyTag_);
         jecUncertainty_ = std::make_unique<JetCorrectionUncertainty>(*jetCorrParameters_);
       } else {
         jetCorrPayloadName_ = cfg.getParameter<std::string>("jetCorrPayloadName");
         jetCorrPayloadToken_ = esConsumes(edm::ESInputTag("", jetCorrPayloadName_));
       }
     }
 
     addResidualJES_ = cfg.getParameter<bool>("addResidualJES");
     if (cfg.exists("jetCorrLabelUpToL3")) {
       jetCorrLabelUpToL3_ = cfg.getParameter<edm::InputTag>("jetCorrLabelUpToL3");
       jetCorrTokenUpToL3_ = mayConsume<reco::JetCorrector>(jetCorrLabelUpToL3_);
     }
     if (cfg.exists("jetCorrLabelUpToL3Res") && addResidualJES_) {
       jetCorrLabelUpToL3Res_ = cfg.getParameter<edm::InputTag>("jetCorrLabelUpToL3Res");
       jetCorrTokenUpToL3Res_ = mayConsume<reco::JetCorrector>(jetCorrLabelUpToL3Res_);
     }
     jetCorrEtaMax_ = (cfg.exists("jetCorrEtaMax")) ? cfg.getParameter<double>("jetCorrEtaMax") : 9.9;
 
     shiftBy_ = cfg.getParameter<double>("shiftBy");
 
     verbosity_ = (cfg.exists("verbosity")) ? cfg.getParameter<int>("verbosity") : 0;
 
     produces<JetCollection>();
   }

Member Function Documentation

◆ produce()

template<typename T , typename Textractor >

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

inlineoverrideprivate

Definition at line 86 of file ShiftedJetProducerT.h.

                                                                 {
     if (verbosity_) {
       std::cout << "<ShiftedJetProducerT::produce>:" << std::endl;
       std::cout << " moduleLabel = " << moduleLabel_ << std::endl;
       std::cout << " src = " << src_.label() << std::endl;
     }
 
     edm::Handle<JetCollection> originalJets;
     evt.getByToken(srcToken_, originalJets);
     edm::Handle<reco::JetCorrector> jetCorrUpToL3;
     evt.getByToken(jetCorrTokenUpToL3_, jetCorrUpToL3);
     edm::Handle<reco::JetCorrector> jetCorrUpToL3Res;
     if (evt.isRealData() && addResidualJES_) {
       evt.getByToken(jetCorrTokenUpToL3Res_, jetCorrUpToL3Res);
     }
     auto shiftedJets = std::make_unique<JetCollection>();
 
     if (!jetCorrPayloadName_.empty()) {
       const JetCorrectorParametersCollection& jetCorrParameterSet = es.getData(jetCorrPayloadToken_);
       const JetCorrectorParameters& jetCorrParameters = (jetCorrParameterSet)[jetCorrUncertaintyTag_];
       jecUncertainty_ = std::make_unique<JetCorrectionUncertainty>(jetCorrParameters);
     }
 
     for (typename JetCollection::const_iterator originalJet = originalJets->begin(); originalJet != originalJets->end();
          ++originalJet) {
       reco::Candidate::LorentzVector originalJetP4 = originalJet->p4();
       if (verbosity_) {
         std::cout << "originalJet: Pt = " << originalJetP4.pt() << ", eta = " << originalJetP4.eta()
                   << ", phi = " << originalJetP4.phi() << std::endl;
       }
 
       double shift = 0.;
       if (jecUncertaintyValue_ != -1.) {
         shift = jecUncertaintyValue_;
       } else {
         jecUncertainty_->setJetEta(originalJetP4.eta());
         jecUncertainty_->setJetPt(originalJetP4.pt());
 
         shift = jecUncertainty_->getUncertainty(true);
       }
       if (verbosity_) {
         std::cout << "shift = " << shift << std::endl;
       }
 
       if (evt.isRealData() && addResidualJES_) {
         const static pat::RawJetExtractorT<T> rawJetExtractor{};
         reco::Candidate::LorentzVector rawJetP4 = rawJetExtractor(*originalJet);
         if (rawJetP4.E() > 1.e-1) {
           reco::Candidate::LorentzVector corrJetP4upToL3 =
               std::is_base_of<class PATJetCorrExtractor, Textractor>::value
                   ? jetCorrExtractor_(*originalJet, jetCorrLabelUpToL3_.label(), jetCorrEtaMax_, &rawJetP4)
                   : jetCorrExtractor_(*originalJet, jetCorrUpToL3.product(), jetCorrEtaMax_, &rawJetP4);
           reco::Candidate::LorentzVector corrJetP4upToL3Res =
               std::is_base_of<class PATJetCorrExtractor, Textractor>::value
                   ? jetCorrExtractor_(*originalJet, jetCorrLabelUpToL3Res_.label(), jetCorrEtaMax_, &rawJetP4)
                   : jetCorrExtractor_(*originalJet, jetCorrUpToL3Res.product(), jetCorrEtaMax_, &rawJetP4);
           if (corrJetP4upToL3.E() > 1.e-1 && corrJetP4upToL3Res.E() > 1.e-1) {
             double residualJES = (corrJetP4upToL3Res.E() / corrJetP4upToL3.E()) - 1.;
             shift = sqrt(shift * shift + residualJES * residualJES);
           }
         }
       }
 
       shift *= shiftBy_;
       if (verbosity_) {
         std::cout << "shift*shiftBy = " << shift << std::endl;
       }
 
       T shiftedJet(*originalJet);
       shiftedJet.setP4((1. + shift) * originalJetP4);
       if (verbosity_) {
         std::cout << "shiftedJet: Pt = " << shiftedJet.pt() << ", eta = " << shiftedJet.eta()
                   << ", phi = " << shiftedJet.phi() << std::endl;
       }
 
       shiftedJets->push_back(shiftedJet);
     }
 
     evt.put(std::move(shiftedJets));
   }