Inheritance diagram for ShiftedMETcorrInputProducer:

Classes
struct	binningEntryType

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

	~ShiftedMETcorrInputProducer () 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< edm::InputTag >	vInputTag

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

Private Attributes
std::vector< binningEntryType * >	binning_

double	shiftBy_

vInputTag	src_

std::vector< edm::EDGetTokenT< CorrMETData > >	srcTokens_

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 px, py and sumEt of "unclustered energy" (PFJets of Pt < 10 GeV plus PFCandidates not within jets) by +/- 1 standard deviation, in order to estimate resulting uncertainty on MET

Author: Christian Veelken, LLR

Definition at line 23 of file ShiftedMETcorrInputProducer.cc.

Member Typedef Documentation

◆ vInputTag

typedef std::vector<edm::InputTag> ShiftedMETcorrInputProducer::vInputTag

private

Definition at line 31 of file ShiftedMETcorrInputProducer.cc.

Constructor & Destructor Documentation

◆ ShiftedMETcorrInputProducer()

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

explicit

Definition at line 56 of file ShiftedMETcorrInputProducer.cc.

                                                                                    {
   src_ = cfg.getParameter<vInputTag>("src");
  
   //--- check that all InputTags refer to the same module label
   //   (i.e. differ by instance label only)
   for (vInputTag::const_iterator src_ref = src_.begin(); src_ref != src_.end(); ++src_ref) {
     for (vInputTag::const_iterator src_test = src_ref; src_test != src_.end(); ++src_test) {
       if (src_test->label() != src_ref->label())
         throw cms::Exception("ShiftedMETcorrInputProducer")
             << "InputTags specified by 'src' Configuration parameter must not refer to different module labels !!\n";
     }
   }
  
   shiftBy_ = cfg.getParameter<double>("shiftBy");
  
   if (cfg.exists("binning")) {
     typedef std::vector<edm::ParameterSet> vParameterSet;
     vParameterSet cfgBinning = cfg.getParameter<vParameterSet>("binning");
     for (vParameterSet::const_iterator cfgBinningEntry = cfgBinning.begin(); cfgBinningEntry != cfgBinning.end();
          ++cfgBinningEntry) {
       binning_.push_back(new binningEntryType(*cfgBinningEntry));
     }
   } else {
     double uncertainty = cfg.getParameter<double>("uncertainty");
     binning_.push_back(new binningEntryType(uncertainty));
   }
  
   for (vInputTag::const_iterator src_i = src_.begin(); src_i != src_.end(); ++src_i) {
     for (std::vector<binningEntryType*>::const_iterator binningEntry = binning_.begin(); binningEntry != binning_.end();
          ++binningEntry) {
       srcTokens_.push_back(consumes<CorrMETData>(
           edm::InputTag(src_i->label(), (*binningEntry)->getInstanceLabel_full(src_i->instance()))));
       produces<CorrMETData>((*binningEntry)->getInstanceLabel_full(src_i->instance()));
     }
   }
 }

References binning_, looper::cfg, shiftBy_, src_, and srcTokens_.

◆ ~ShiftedMETcorrInputProducer()

ShiftedMETcorrInputProducer::~ShiftedMETcorrInputProducer ( )

override

Definition at line 93 of file ShiftedMETcorrInputProducer.cc.

                                                           {
   for (std::vector<binningEntryType*>::const_iterator it = binning_.begin(); it != binning_.end(); ++it) {
     delete (*it);
   }
 }

References binning_.

Member Function Documentation

◆ produce()

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

overrideprivate

Definition at line 99 of file ShiftedMETcorrInputProducer.cc.

                                                                                 {
   unsigned countToken(0);
   for (vInputTag::const_iterator src_i = src_.begin(); src_i != src_.end(); ++src_i) {
     for (std::vector<binningEntryType*>::iterator binningEntry = binning_.begin(); binningEntry != binning_.end();
          ++binningEntry) {
       edm::Handle<CorrMETData> originalObject;
       evt.getByToken(srcTokens_.at(countToken), originalObject);
       ++countToken;
  
       double shift = shiftBy_ * (*binningEntry)->binUncertainty_;
  
       auto shiftedObject = std::make_unique<CorrMETData>(*originalObject);
       //--- MET balances momentum of reconstructed particles,
       //    hence variations of "unclustered energy" and MET are opposite in sign
       shiftedObject->mex = -shift * originalObject->mex;
       shiftedObject->mey = -shift * originalObject->mey;
       shiftedObject->sumet = shift * originalObject->sumet;
  
       evt.put(std::move(shiftedObject), (*binningEntry)->getInstanceLabel_full(src_i->instance()));
     }
   }
 }