Inheritance diagram for pat::PATMETProducer:

Public Member Functions
	PATMETProducer (const edm::ParameterSet &iConfig)

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

	~PATMETProducer () 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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
const reco::METCovMatrix	getMETCovMatrix (const edm::Event &event, const edm::EventSetup &iSetup, const reco::MET &met, double &sumPtUnclustered) const

Private Attributes
bool	addEfficiencies_

bool	addGenMET_

bool	addMuonCorr_

bool	addResolutions_

bool	calculateMETSignificance_

pat::helper::EfficiencyLoader	efficiencyLoader_

GreaterByEt< MET >	eTComparator_

edm::EDGetTokenT< edm::View< reco::GenMET > >	genMETToken_

std::string	jetResPhiType_

std::string	jetResPtType_

std::string	jetSFType_

edm::EDGetTokenT< edm::View< reco::Jet > >	jetToken_

std::vector< edm::EDGetTokenT< edm::View< reco::Candidate > > >	lepTokens_

metsig::METSignificance *	metSigAlgo_

edm::InputTag	metSrc_

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

edm::InputTag	muonSrc_

edm::EDGetTokenT< edm::View< reco::Candidate > >	pfCandToken_

pat::helper::KinResolutionsLoader	resolutionLoader_

edm::EDGetTokenT< double >	rhoToken_

pat::PATUserDataHelper< pat::MET >	userDataHelper_

bool	useUserData_

edm::EDGetTokenT< edm::ValueMap< float > >	weightsToken_

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

Produces the pat::MET.

The PATMETProducer produces the analysis-level pat::MET starting from a collection of objects of METType.

Author: Steven Lowette

Version

Id: PATMETProducer.h,v 1.10 2009/06/25 23:49:35 gpetrucc Exp

Definition at line 33 of file PATMETProducer.cc.

Constructor & Destructor Documentation

◆ PATMETProducer()

PATMETProducer::PATMETProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 83 of file PATMETProducer.cc.

                                                              : useUserData_(iConfig.exists("userData")) {
   // initialize the configurables
   metSrc_ = iConfig.getParameter<edm::InputTag>("metSource");
   metToken_ = consumes<edm::View<reco::MET>>(metSrc_);
   addGenMET_ = iConfig.getParameter<bool>("addGenMET");
   genMETToken_ = mayConsume<edm::View<reco::GenMET>>(iConfig.getParameter<edm::InputTag>("genMETSource"));
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
  
   // Efficiency configurables
   addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
   if (addEfficiencies_) {
     efficiencyLoader_ =
         pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
   }
  
   // Resolution configurables
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
     resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
   }
  
   // Check to see if the user wants to add user data
   if (useUserData_) {
     userDataHelper_ = PATUserDataHelper<MET>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
   }
  
   // MET Significance
   calculateMETSignificance_ = iConfig.getParameter<bool>("computeMETSignificance");
   if (calculateMETSignificance_) {
     edm::InputTag srcWeights = iConfig.getParameter<edm::InputTag>("srcWeights");
     if (!srcWeights.label().empty())
       weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);
     metSigAlgo_ = new metsig::METSignificance(iConfig);
     rhoToken_ = consumes<double>(iConfig.getParameter<edm::InputTag>("srcRho"));
     jetSFType_ = iConfig.getParameter<std::string>("srcJetSF");
     jetResPtType_ = iConfig.getParameter<std::string>("srcJetResPt");
     jetResPhiType_ = iConfig.getParameter<std::string>("srcJetResPhi");
     jetToken_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("srcJets"));
     pfCandToken_ = consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("srcPFCands"));
     std::vector<edm::InputTag> srcLeptonsTags = iConfig.getParameter<std::vector<edm::InputTag>>("srcLeptons");
     for (std::vector<edm::InputTag>::const_iterator it = srcLeptonsTags.begin(); it != srcLeptonsTags.end(); it++) {
       lepTokens_.push_back(consumes<edm::View<reco::Candidate>>(*it));
     }
   }
  
   // produces vector of mets
   produces<std::vector<MET>>();
 }

References addEfficiencies_, addGenMET_, addResolutions_, calculateMETSignificance_, efficiencyLoader_, genMETToken_, edm::ParameterSet::getParameter(), jetResPhiType_, jetResPtType_, jetSFType_, jetToken_, lepTokens_, metSigAlgo_, METSignificance_cfi::METSignificance, metSrc_, metToken_, pfCandToken_, resolutionLoader_, rhoToken_, HLT_FULL_cff::srcWeights, AlCaHLTBitMon_QueryRunRegistry::string, userDataHelper_, useUserData_, and weightsToken_.

◆ ~PATMETProducer()

PATMETProducer::~PATMETProducer ( )

override

Definition at line 132 of file PATMETProducer.cc.

132 {}

Member Function Documentation

◆ fillDescriptions()

void PATMETProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 201 of file PATMETProducer.cc.

                                                                                 {
   edm::ParameterSetDescription iDesc;
   iDesc.setComment("PAT MET producer module");
  
   // input source
   iDesc.add<edm::InputTag>("metSource", edm::InputTag("no default"))->setComment("input collection");
  
   // MC configurations
   iDesc.add<bool>("addGenMET", false);
   iDesc.add<edm::InputTag>("genMETSource", edm::InputTag("genMetCalo"));
  
   pat::helper::KinResolutionsLoader::fillDescription(iDesc);
  
   // Efficiency configurables
   edm::ParameterSetDescription efficienciesPSet;
   efficienciesPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("efficiencies", efficienciesPSet);
   iDesc.add<bool>("addEfficiencies", false);
  
   // Check to see if the user wants to add user data
   edm::ParameterSetDescription userDataPSet;
   PATUserDataHelper<MET>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
  
   // muon correction
   iDesc.add<bool>("addMuonCorrections", false);
   iDesc.add<edm::InputTag>("muonSource", edm::InputTag("muons"));
 }

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), HLT_FULL_cff::InputTag, edm::ParameterSetDescription::setAllowAnything(), and edm::ParameterSetDescription::setComment().

◆ getMETCovMatrix()

const reco::METCovMatrix PATMETProducer::getMETCovMatrix	(	const edm::Event &	event,
		const edm::EventSetup &	iSetup,
		const reco::MET &	met,
		double &	sumPtUnclustered
	)		const

private

Definition at line 230 of file PATMETProducer.cc.

                                                                                          {
   std::vector<edm::Handle<reco::CandidateView>> leptons;
   for (std::vector<edm::EDGetTokenT<edm::View<reco::Candidate>>>::const_iterator srcLeptons_i = lepTokens_.begin();
        srcLeptons_i != lepTokens_.end();
        ++srcLeptons_i) {
     edm::Handle<reco::CandidateView> leptons_i;
     event.getByToken(*srcLeptons_i, leptons_i);
     leptons.push_back(leptons_i);
   }
   // jets
   edm::Handle<edm::View<reco::Jet>> inputJets;
   event.getByToken(jetToken_, inputJets);
  
   //candidates
   edm::Handle<edm::View<reco::Candidate>> inputCands;
   event.getByToken(pfCandToken_, inputCands);
  
   edm::Handle<double> rho;
   event.getByToken(rhoToken_, rho);
  
   edm::Handle<edm::ValueMap<float>> weights;
   if (!weightsToken_.isUninitialized())
     event.getByToken(weightsToken_, weights);
  
   JME::JetResolution resPtObj = JME::JetResolution::get(iSetup, jetResPtType_);
   JME::JetResolution resPhiObj = JME::JetResolution::get(iSetup, jetResPhiType_);
   JME::JetResolutionScaleFactor resSFObj = JME::JetResolutionScaleFactor::get(iSetup, jetSFType_);
  
   //Compute the covariance matrix and fill it
   const edm::ValueMap<float>* weightsPtr = nullptr;
   if (met.isWeighted()) {
     if (weightsToken_.isUninitialized())
       throw cms::Exception("InvalidInput") << "MET is weighted (e.g. PUPPI), but no weights given in PATMETProducer\n";
     weightsPtr = &*weights;
   }
   reco::METCovMatrix cov = metSigAlgo_->getCovariance(*inputJets,
                                                       leptons,
                                                       inputCands,
                                                       *rho,
                                                       resPtObj,
                                                       resPhiObj,
                                                       resSFObj,
                                                       event.isRealData(),
                                                       sumPtUnclustered,
                                                       weightsPtr);
  
   return cov;
 }

References JME::JetResolution::get(), JME::JetResolutionScaleFactor::get(), metsig::METSignificance::getCovariance(), HLT_FULL_cff::inputJets, edm::EDGetTokenT< T >::isUninitialized(), jetResPhiType_, jetResPtType_, jetSFType_, jetToken_, lepTokens_, HLT_FULL_cff::leptons, BTaggingMonitor_cfi::met, metSigAlgo_, pfCandToken_, rhoToken_, met_cff::sumPtUnclustered, trackerHitRTTI::vector, HLT_FULL_cff::weights, and weightsToken_.

Referenced by produce().

◆ produce()

void PATMETProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 134 of file PATMETProducer.cc.

                                                                           {
   // Get the vector of MET's from the event
   edm::Handle<edm::View<reco::MET>> mets;
   iEvent.getByToken(metToken_, mets);
  
   if (mets->size() != 1)
     throw cms::Exception("Corrupt Data") << "The input MET collection " << metSrc_.encode() << " has size "
                                          << mets->size() << " instead of 1 as it should.\n";
   if (efficiencyLoader_.enabled())
     efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled())
     resolutionLoader_.newEvent(iEvent, iSetup);
  
   // Get the vector of generated met from the event if needed
   edm::Handle<edm::View<reco::GenMET>> genMETs;
   if (addGenMET_) {
     iEvent.getByToken(genMETToken_, genMETs);
   }
  
   // loop over mets
   std::vector<MET>* patMETs = new std::vector<MET>();
   for (edm::View<reco::MET>::const_iterator itMET = mets->begin(); itMET != mets->end(); itMET++) {
     // construct the MET from the ref -> save ref to original object
     unsigned int idx = itMET - mets->begin();
     edm::RefToBase<reco::MET> metsRef = mets->refAt(idx);
     edm::Ptr<reco::MET> metsPtr = mets->ptrAt(idx);
     MET amet(metsRef);
     // add the generated MET
     if (addGenMET_)
       amet.setGenMET((*genMETs)[idx]);
  
     //add the MET significance
     if (calculateMETSignificance_) {
       double sumPtUnclustered = 0;
       const reco::METCovMatrix& sigcov = getMETCovMatrix(iEvent, iSetup, amet, sumPtUnclustered);
       amet.setSignificanceMatrix(sigcov);
       double metSig = metSigAlgo_->getSignificance(sigcov, amet);
       amet.setMETSignificance(metSig);
       amet.setMETSumPtUnclustered(sumPtUnclustered);
     }
  
     if (efficiencyLoader_.enabled()) {
       efficiencyLoader_.setEfficiencies(amet, metsRef);
     }
  
     if (resolutionLoader_.enabled()) {
       resolutionLoader_.setResolutions(amet);
     }
  
     if (useUserData_) {
       userDataHelper_.add(amet, iEvent, iSetup);
     }
  
     // correct for muons if demanded... never more: it's now done by JetMETCorrections
     // add the MET to the vector of METs
     patMETs->push_back(amet);
   }
  
   // sort MET in ET .. don't mess with this
   //  std::sort(patMETs->begin(), patMETs->end(), eTComparator_);
  
   // put genEvt object in Event
   std::unique_ptr<std::vector<MET>> myMETs(patMETs);
   iEvent.put(std::move(myMETs));
 }