Inheritance diagram for ShiftedPFCandidateProducerForNoPileUpPFMEt:

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

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 Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::unique_ptr< JetCorrectionUncertainty >	jecUncertainty_

edm::FileInPath	jetCorrInputFileName_

std::unique_ptr< JetCorrectorParameters >	jetCorrParameters_

std::string	jetCorrPayloadName_

edm::ESGetToken< JetCorrectorParametersCollection, JetCorrectionsRecord >	jetCorrPayloadToken_

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<>
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

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 40 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

Constructor & Destructor Documentation

◆ ShiftedPFCandidateProducerForNoPileUpPFMEt()

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

explicit

Definition at line 64 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

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

     : 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_ =
         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_));
   }
 
   minJetPt_ = cfg.getParameter<double>("minJetPt");
 
   shiftBy_ = cfg.getParameter<double>("shiftBy");
 
   unclEnUncertainty_ = cfg.getParameter<double>("unclEnUncertainty");
 
   produces<reco::PFCandidateCollection>();
 }

Member Function Documentation

◆ produce()

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

overrideprivate

Definition at line 90 of file ShiftedPFCandidateProducerForNoPileUpPFMEt.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, MillePedeFileConverter_cfg::e, reco::LeafCandidate::eta(), edm::Event::getByToken(), edm::EventSetup::getData(), reco::PFJet::getPFConstituents(), jecUncertainty_, metsig::jet, jetCorrPayloadName_, jetCorrPayloadToken_, jetCorrUncertaintyTag_, PDWG_EXODelayedJetMET_cff::jets, minJetPt_, eostools::move(), reco::LeafCandidate::pt(), edm::Event::put(), objectSelection_cff::selectedJets, reco::LeafCandidate::setP4(), edm::shift, shiftBy_, srcJetsToken_, srcPFCandidatesToken_, and unclEnUncertainty_.

                                                                                                {
   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()) {
     const JetCorrectorParametersCollection& jetCorrParameterSet = es.getData(jetCorrPayloadToken_);
     const JetCorrectorParameters& jetCorrParameters = (jetCorrParameterSet)[jetCorrUncertaintyTag_];
     jecUncertainty_ = std::make_unique<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));
 }