#include <ShiftedPFCandidateProducerForNoPileUpPFMEt.h>

Inheritance diagram for ShiftedPFCandidateProducerForNoPileUpPFMEt:

Public Member Functions
	ShiftedPFCandidateProducerForNoPileUpPFMEt (const edm::ParameterSet &)

	~ShiftedPFCandidateProducerForNoPileUpPFMEt () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
JetCorrectionUncertainty *	jecUncertainty_

edm::FileInPath	jetCorrInputFileName_

JetCorrectorParameters *	jetCorrParameters_

std::string	jetCorrPayloadName_

std::string	jetCorrUncertaintyTag_

double	minJetPt_

double	shiftBy_

edm::EDGetTokenT< reco::PFJetCollection >	srcJetsToken_

edm::EDGetTokenT< reco::PFCandidateCollection >	srcPFCandidatesToken_

double	unclEnUncertainty_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Vary energy of PFCandidates which are (are not) within jets of Pt > 10 GeV by jet energy uncertainty (by 10% "unclustered" energy uncertainty)

NOTE: Auxiliary class specific to estimating systematic uncertainty on PFMET reconstructed by no-PU MET reconstruction algorithm (implemented in JetMETCorrections/Type1MET/src/NoPileUpPFMETProducer.cc)

In case all PFCandidates not within jets of Pt > 30 GeV would be varied by the 10% "unclustered" energy uncertainty, the systematic uncertainty on the reconstructed no-PU MET would be overestimated significantly !!

Author: Christian Veelken, LLR

Definition at line 42 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.h.

Constructor & Destructor Documentation

◆ ShiftedPFCandidateProducerForNoPileUpPFMEt()

ShiftedPFCandidateProducerForNoPileUpPFMEt::ShiftedPFCandidateProducerForNoPileUpPFMEt ( const edm::ParameterSet & cfg )

explicit

Definition at line 8 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

     : srcPFCandidatesToken_(consumes<reco::PFCandidateCollection>(cfg.getParameter<edm::InputTag>("srcPFCandidates"))),
       srcJetsToken_(consumes<reco::PFJetCollection>(cfg.getParameter<edm::InputTag>("srcJets"))) {
   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");
   }
  
   minJetPt_ = cfg.getParameter<double>("minJetPt");
  
   shiftBy_ = cfg.getParameter<double>("shiftBy");
  
   unclEnUncertainty_ = cfg.getParameter<double>("unclEnUncertainty");
  
   produces<reco::PFCandidateCollection>();
 }

References looper::cfg, edm::FileInPath::fullPath(), jecUncertainty_, jetCorrInputFileName_, jetCorrParameters_, jetCorrPayloadName_, jetCorrUncertaintyTag_, edm::FileInPath::location(), minJetPt_, shiftBy_, AlCaHLTBitMon_QueryRunRegistry::string, unclEnUncertainty_, and edm::FileInPath::Unknown.

◆ ~ShiftedPFCandidateProducerForNoPileUpPFMEt()

ShiftedPFCandidateProducerForNoPileUpPFMEt::~ShiftedPFCandidateProducerForNoPileUpPFMEt ( )

override

Definition at line 32 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

                                                                                         {
   // nothing to be done yet...
 }

Member Function Documentation

◆ produce()

void ShiftedPFCandidateProducerForNoPileUpPFMEt::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 36 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

                                                                                                {
   edm::Handle<reco::PFCandidateCollection> originalPFCandidates;
   evt.getByToken(srcPFCandidatesToken_, originalPFCandidates);
  
   edm::Handle<reco::PFJetCollection> jets;
   evt.getByToken(srcJetsToken_, jets);
  
   std::vector<const reco::PFJet*> selectedJets;
   for (reco::PFJetCollection::const_iterator jet = jets->begin(); jet != jets->end(); ++jet) {
     if (jet->pt() > minJetPt_)
       selectedJets.push_back(&(*jet));
   }
  
   if (!jetCorrPayloadName_.empty()) {
     edm::ESHandle<JetCorrectorParametersCollection> jetCorrParameterSet;
     es.get<JetCorrectionsRecord>().get(jetCorrPayloadName_, jetCorrParameterSet);
     const JetCorrectorParameters& jetCorrParameters = (*jetCorrParameterSet)[jetCorrUncertaintyTag_];
     delete jecUncertainty_;
     jecUncertainty_ = new JetCorrectionUncertainty(jetCorrParameters);
   }
  
   auto shiftedPFCandidates = std::make_unique<reco::PFCandidateCollection>();
   for (reco::PFCandidateCollection::const_iterator originalPFCandidate = originalPFCandidates->begin();
        originalPFCandidate != originalPFCandidates->end();
        ++originalPFCandidate) {
     const reco::PFJet* jet_matched = nullptr;
     for (std::vector<const reco::PFJet*>::iterator jet = selectedJets.begin(); jet != selectedJets.end(); ++jet) {
       std::vector<reco::PFCandidatePtr> jetConstituents = (*jet)->getPFConstituents();
       for (std::vector<reco::PFCandidatePtr>::const_iterator jetConstituent = jetConstituents.begin();
            jetConstituent != jetConstituents.end() && !jet_matched;
            ++jetConstituent) {
         if (deltaR(originalPFCandidate->p4(), (*jetConstituent)->p4()) < 1.e-2)
           jet_matched = (*jet);
       }
     }
  
     double shift = 0.;
     if (jet_matched) {
       jecUncertainty_->setJetEta(jet_matched->eta());
       jecUncertainty_->setJetPt(jet_matched->pt());
  
       shift = jecUncertainty_->getUncertainty(true);
     } else {
       shift = unclEnUncertainty_;
     }
  
     shift *= shiftBy_;
  
     reco::Candidate::LorentzVector shiftedPFCandidateP4 = originalPFCandidate->p4();
     shiftedPFCandidateP4 *= (1. + shift);
  
     reco::PFCandidate shiftedPFCandidate(*originalPFCandidate);
     shiftedPFCandidate.setP4(shiftedPFCandidateP4);
  
     shiftedPFCandidates->push_back(shiftedPFCandidate);
   }
  
   evt.put(std::move(shiftedPFCandidates));
 }