Inheritance diagram for ShiftedPFCandidateProducerForPFNoPUMEt:

Public Member Functions
	ShiftedPFCandidateProducerForPFNoPUMEt (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_

bool	jecValidFileName_

edm::FileInPath	jetCorrInputFileName_

std::unique_ptr< JetCorrectorParameters >	jetCorrParameters_

std::string	jetCorrPayloadName_

edm::ESGetToken< JetCorrectorParametersCollection, JetCorrectionsRecord >	jetCorrPayloadToken_

std::string	jetCorrUncertaintyTag_

double	minJetPt_

std::string	moduleLabel_

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/PFNoPUMETProducer.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 ShiftedPFCandidateProducerForPFNoPUMEt.cc.

Constructor & Destructor Documentation

◆ ShiftedPFCandidateProducerForPFNoPUMEt()

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

explicit

Definition at line 72 of file ShiftedPFCandidateProducerForPFNoPUMEt.cc.

References looper::cfg, deDxTools::esConsumes(), edm::FileInPath::fullPath(), jecUncertainty_, jecValidFileName_, 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");
 
   jecValidFileName_ = cfg.exists("jetCorrInputFileName");
   if (jecValidFileName_) {
     jetCorrInputFileName_ = cfg.getParameter<edm::FileInPath>("jetCorrInputFileName");
     if (jetCorrInputFileName_.location() == edm::FileInPath::Unknown)
       throw cms::Exception("ShiftedJetProducerT")
           << " Failed to find JEC parameter file = " << jetCorrInputFileName_ << " !!\n";
     edm::LogInfo("ShiftedPFCandidateProducerForPFNoPUMEt")
         << "Reading JEC parameters = " << jetCorrUncertaintyTag_ << " from file = " << jetCorrInputFileName_.fullPath()
         << "." << std::endl;
     jetCorrParameters_ =
         std::make_unique<JetCorrectorParameters>(jetCorrInputFileName_.fullPath(), jetCorrUncertaintyTag_);
     jecUncertainty_ = std::make_unique<JetCorrectionUncertainty>(*jetCorrParameters_);
   } else {
     edm::LogInfo("ShiftedPFCandidateProducerForPFNoPUMEt")
         << "Reading JEC parameters = " << jetCorrUncertaintyTag_ << " from DB/SQLlite file." << std::endl;
     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 ShiftedPFCandidateProducerForPFNoPUMEt::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 105 of file ShiftedPFCandidateProducerForPFNoPUMEt.cc.

References HLTMuonOfflineAnalyzer_cfi::deltaR2, reco::LeafCandidate::eta(), edm::Event::getByToken(), edm::EventSetup::getData(), jecUncertainty_, metsig::jet, jetCorrPayloadName_, jetCorrPayloadToken_, jetCorrUncertaintyTag_, singleTopDQM_cfi::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()) {
     JetCorrectorParametersCollection const& 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 (auto jet : selectedJets) {
       for (const auto& jetc : jet->getPFConstituents()) {
         if (deltaR2(originalPFCandidate->p4(), jetc->p4()) < dR2Match) {
           jet_matched = jet;
           break;
         }
       }
       if (jet_matched)
         break;
     }
 
     double shift = 0.;
     if (jet_matched != nullptr) {
       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));
 }