#include <CaloJetMETcorrInputProducerT.h>

Inheritance diagram for CaloJetMETcorrInputProducerT< T, Textractor >:

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

	~CaloJetMETcorrInputProducerT ()

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

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Private Attributes
double	jetCorrEtaMax_

Textractor	jetCorrExtractor_

edm::InputTag	jetCorrLabel_

edm::EDGetTokenT< reco::JetCorrector >	jetCorrToken_

edm::EDGetTokenT< edm::View< reco::MET > >	metToken_

std::string	moduleLabel_

edm::InputTag	offsetCorrLabel_

edm::EDGetTokenT< reco::JetCorrector >	offsetCorrToken_

bool	skipEM_

double	skipEMfractionThreshold_

edm::InputTag	srcMET_

edm::EDGetTokenT< std::vector< T > >	token_

double	type1JetPtThreshold_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::global::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<typename T, typename Textractor>
class CaloJetMETcorrInputProducerT< T, Textractor >

Definition at line 63 of file CaloJetMETcorrInputProducerT.h.

Constructor & Destructor Documentation

template<typename T , typename Textractor >

CaloJetMETcorrInputProducerT< T, Textractor >::CaloJetMETcorrInputProducerT ( const edm::ParameterSet & cfg )

inlineexplicit

Definition at line 67 of file CaloJetMETcorrInputProducerT.h.

References edm::ParameterSet::exists(), and edm::ParameterSet::getParameter().

     : moduleLabel_(cfg.getParameter<std::string>("@module_label")),
       offsetCorrLabel_("")
   {
     token_ = consumes<std::vector<T> >(cfg.getParameter<edm::InputTag>("src"));
 
     if ( cfg.exists("offsetCorrLabel") ) {
       offsetCorrLabel_ = cfg.getParameter<edm::InputTag>("offsetCorrLabel");
       offsetCorrToken_ = consumes<reco::JetCorrector>(offsetCorrLabel_);
     }
     jetCorrLabel_ = cfg.getParameter<edm::InputTag>("jetCorrLabel");
     jetCorrToken_ = consumes<reco::JetCorrector>(jetCorrLabel_);
 
     jetCorrEtaMax_ = ( cfg.exists("jetCorrEtaMax") ) ?
       cfg.getParameter<double>("jetCorrEtaMax") : 9.9;
 
     type1JetPtThreshold_ = cfg.getParameter<double>("type1JetPtThreshold");
 
     skipEM_ = cfg.getParameter<bool>("skipEM");
     if ( skipEM_ ) {
       skipEMfractionThreshold_ = cfg.getParameter<double>("skipEMfractionThreshold");
     }
 
     if(cfg.exists("srcMET"))
       {
     srcMET_ = cfg.getParameter<edm::InputTag>("srcMET");
     metToken_ = consumes<edm::View<reco::MET> >(cfg.getParameter<edm::InputTag>("srcMET"));
       }
 
     produces<CorrMETData>("type1");
     produces<CorrMETData>("type2");
     produces<CorrMETData>("offset");
   }

template<typename T , typename Textractor >

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

inline

Definition at line 100 of file CaloJetMETcorrInputProducerT.h.

100 {}

Member Function Documentation

template<typename T , typename Textractor >

void CaloJetMETcorrInputProducerT< T, Textractor >::produce	(	edm::StreamID	,
		edm::Event &	evt,
		const edm::EventSetup &	es
	)		const

inlineoverrideprivate

Definition at line 104 of file CaloJetMETcorrInputProducerT.h.

References edm::Event::getByToken(), fwrapper::jets, RazorAnalyzer::met, eostools::move(), edm::Handle< T >::product(), and edm::Event::put().

   {
     std::unique_ptr<CorrMETData> type1Correction(new CorrMETData());
     std::unique_ptr<CorrMETData> unclEnergySum(new CorrMETData());
     std::unique_ptr<CorrMETData> offsetEnergySum(new CorrMETData());
 
     edm::Handle<reco::JetCorrector> jetCorr;
     evt.getByToken(jetCorrToken_, jetCorr);
 
     typedef std::vector<T> JetCollection;
     edm::Handle<JetCollection> jets;
     evt.getByToken(token_, jets);
 
     typedef edm::View<reco::MET> METView;
     edm::Handle<METView> met;
     if ( srcMET_.label() != "" ) {
       evt.getByToken(metToken_, met);
       if ( met->size() != 1 )
     throw cms::Exception("CaloJetMETcorrInputProducer::produce")
       << "Failed to find unique MET in the event, src = " << srcMET_.label() << " !!\n";
 
 //--- compute "unclustered energy" by sutracting from the reconstructed MET
 //   (i.e. from the negative vectorial sum of all particles reconstructed in the event)
 //    the momenta of (high Pt) jets which enter Type 1 MET corrections
 //
 //    NOTE: MET = -(jets + muons + "unclustered energy"),
 //          so "unclustered energy" = -(MET + jets + muons),
 //          i.e. (high Pt) jets enter the sum of "unclustered energy" with negative sign.
 //
       unclEnergySum->mex   = -met->front().px();
       unclEnergySum->mey   = -met->front().py();
       unclEnergySum->sumet =  met->front().sumEt();
     }
 
     int numJets = jets->size();
     for ( int jetIndex = 0; jetIndex < numJets; ++jetIndex ) {
       const T& rawJet = jets->at(jetIndex);
 
       const CaloJetMETcorrInputProducer_namespace::InputTypeCheckerT<T> checkInputType{};
       checkInputType(rawJet);
 
       const CaloJetMETcorrInputProducer_namespace::RawJetExtractorT<T> rawJetExtractor;
       reco::Candidate::LorentzVector rawJetP4 = rawJetExtractor(rawJet);
 
       reco::Candidate::LorentzVector corrJetP4;
       if ( checkInputType.isPatJet(rawJet) )
         corrJetP4 = jetCorrExtractor_(rawJet, jetCorrLabel_.label(), jetCorrEtaMax_);
       else
         corrJetP4 = jetCorrExtractor_(rawJet, jetCorr.product(), jetCorrEtaMax_);
 
       if ( corrJetP4.pt() > type1JetPtThreshold_ ) {
 
     unclEnergySum->mex   -= rawJetP4.px();
     unclEnergySum->mey   -= rawJetP4.py();
     unclEnergySum->sumet -= rawJetP4.Et();
 
     if ( skipEM_ && rawJet.emEnergyFraction() > skipEMfractionThreshold_ ) continue;
 
     reco::Candidate::LorentzVector rawJetP4offsetCorr = rawJetP4;
     if ( !offsetCorrLabel_.label().empty() ) {
           edm::Handle<reco::JetCorrector> offsetCorr;
           evt.getByToken(offsetCorrToken_, offsetCorr);
           if (  checkInputType.isPatJet(rawJet) )
             rawJetP4offsetCorr = jetCorrExtractor_(rawJet, offsetCorrLabel_.label(), jetCorrEtaMax_);
           else
         rawJetP4offsetCorr = jetCorrExtractor_(rawJet, offsetCorr.product(), jetCorrEtaMax_);
 
       offsetEnergySum->mex   += (rawJetP4.px() - rawJetP4offsetCorr.px());
       offsetEnergySum->mey   += (rawJetP4.py() - rawJetP4offsetCorr.py());
       offsetEnergySum->sumet += (rawJetP4.Et() - rawJetP4offsetCorr.Et());
     }
 
 //--- MET balances momentum of reconstructed particles,
 //    hence correction to jets and corresponding Type 1 MET correction are of opposite sign
     type1Correction->mex   -= (corrJetP4.px() - rawJetP4offsetCorr.px());
     type1Correction->mey   -= (corrJetP4.py() - rawJetP4offsetCorr.py());
     type1Correction->sumet += (corrJetP4.Et() - rawJetP4offsetCorr.Et());
       }
     }
 
 //--- add
 //     o Type 1 MET correction                (difference corrected-uncorrected jet energy for jets of (corrected) Pt > 20 GeV)
 //     o momentum sum of "unclustered energy" (jets of (corrected) Pt < 20 GeV)
 //     o momentum sum of "offset energy"      (sum of energy attributed to pile-up/underlying event)
 //    to the event
     evt.put(std::move(type1Correction), "type1");
     evt.put(std::move(unclEnergySum),   "type2");
     evt.put(std::move(offsetEnergySum), "offset");
   }