#include <ShiftedJetProducerT.h>

Inheritance diagram for ShiftedJetProducerT< T, Textractor >:

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

	~ShiftedJetProducerT () 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

Private Types
typedef std::vector< T >	JetCollection

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

Private Attributes
bool	addResidualJES_

JetCorrectionUncertainty *	jecUncertainty_

double	jecUncertaintyValue_

double	jetCorrEtaMax_

Textractor	jetCorrExtractor_

edm::FileInPath	jetCorrInputFileName_

edm::InputTag	jetCorrLabelUpToL3_

edm::InputTag	jetCorrLabelUpToL3Res_

JetCorrectorParameters *	jetCorrParameters_

std::string	jetCorrPayloadName_

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_ = new JetCorrectorParameters(jetCorrInputFileName_.fullPath(), jetCorrUncertaintyTag_);
         jecUncertainty_ = new JetCorrectionUncertainty(*jetCorrParameters_);
       } else {
         jetCorrPayloadName_ = cfg.getParameter<std::string>("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>();
   }

◆ ~ShiftedJetProducerT()

template<typename T , typename Textractor >

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

inlineoverride

Definition at line 82 of file ShiftedJetProducerT.h.

                                   {
     delete jetCorrParameters_;
     delete jecUncertainty_;
   }

References ShiftedJetProducerT< T, Textractor >::jecUncertainty_, and ShiftedJetProducerT< T, Textractor >::jetCorrParameters_.

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 88 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()) {
       edm::ESHandle<JetCorrectorParametersCollection> jetCorrParameterSet;
       es.get<JetCorrectionsRecord>().get(jetCorrPayloadName_, jetCorrParameterSet);
       const JetCorrectorParameters& jetCorrParameters = (*jetCorrParameterSet)[jetCorrUncertaintyTag_];
       delete jecUncertainty_;
       jecUncertainty_ = new 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));
   }