#include <PFMETProducer.h>

Inheritance diagram for cms::PFMETProducer:

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

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

	~PFMETProducer () 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
reco::METCovMatrix	getMETCovMatrix (const edm::Event &event, const edm::EventSetup &, const edm::Handle< edm::View< reco::Candidate >> &input) const

Private Attributes
bool	applyWeight_

bool	calculateSignificance_

double	globalThreshold_

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

edm::ESGetToken< JME::JetResolutionObject, JetResolutionRcd >	jetResPhiToken_

edm::ESGetToken< JME::JetResolutionObject, JetResolutionRcd >	jetResPtToken_

edm::ESGetToken< JME::JetResolutionObject, JetResolutionScaleFactorRcd >	jetSFToken_

double	jetThreshold_

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

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

metsig::METSignificance *	metSigAlgo_

edm::EDGetTokenT< double >	rhoToken_

edm::InputTag	src_

edm::ValueMap< float > const *	weights_

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

Definition at line 57 of file PFMETProducer.h.

Constructor & Destructor Documentation

◆ PFMETProducer()

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

explicit

Definition at line 17 of file PFMETProducer.cc.

References isoTrack_cff::alias, applyWeight_, calculateSignificance_, deDxTools::esConsumes(), edm::ParameterSet::getParameter(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, jetResPhiToken_, jetResPtToken_, jetSFToken_, jetToken_, edm::InputTag::label(), lepTokens_, metSigAlgo_, METSignificance_cfi::METSignificance, rhoToken_, src_, runBasic_cfi::srcWeights, AlCaHLTBitMon_QueryRunRegistry::string, and weightsToken_.

       : src_(iConfig.getParameter<edm::InputTag>("src")),
         inputToken_(consumes<edm::View<reco::Candidate>>(src_)),
         calculateSignificance_(iConfig.getParameter<bool>("calculateSignificance")),
         globalThreshold_(iConfig.getParameter<double>("globalThreshold")),
         applyWeight_(iConfig.getParameter<bool>("applyWeight")),
         weights_(nullptr) {
     if (applyWeight_) {
       edm::InputTag srcWeights = iConfig.getParameter<edm::InputTag>("srcWeights");
       if (srcWeights.label().empty())
         throw cms::Exception("InvalidInput") << "applyWeight set to True, but no weights given in PFMETProducer\n";
       if (srcWeights.label() == src_.label())
         edm::LogWarning("PFMETProducer")
             << "Particle and weights collection have the same label. You may be applying the same weights twice.\n";
       weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);
     }
     if (calculateSignificance_) {
       metSigAlgo_ = new metsig::METSignificance(iConfig);
 
       jetToken_ = mayConsume<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("srcJets"));
       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(mayConsume<edm::View<reco::Candidate>>(*it));
       }
 
       jetSFToken_ = esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("srcJetSF")));
       jetResPtToken_ = esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("srcJetResPt")));
       jetResPhiToken_ = esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("srcJetResPhi")));
       rhoToken_ = consumes<double>(iConfig.getParameter<edm::InputTag>("srcRho"));
     }
 
     std::string alias = iConfig.getParameter<std::string>("alias");
 
     produces<reco::PFMETCollection>().setBranchAlias(alias);
   }

◆ ~PFMETProducer()

cms::PFMETProducer::~PFMETProducer ( )

inlineoverride

Definition at line 60 of file PFMETProducer.h.

60 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 132 of file PFMETProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, submitPVValidationJobs::params, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                  {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("src", edm::InputTag("particleFlow"));
     desc.add<double>("globalThreshold", 0.);
     desc.add<std::string>("alias", "@module_label");
     desc.add<bool>("calculateSignificance", false);
     desc.addOptional<edm::InputTag>("srcJets");
     desc.addOptional<std::vector<edm::InputTag>>("srcLeptons");
     desc.addOptional<std::string>("srcJetSF");
     desc.addOptional<std::string>("srcJetResPt");
     desc.addOptional<std::string>("srcJetResPhi");
     desc.addOptional<edm::InputTag>("srcRho");
     edm::ParameterSetDescription params;
     params.setAllowAnything();  // FIXME: This still needs to be defined in METSignficance
     desc.addOptional<edm::ParameterSetDescription>("parameters", params);
     edm::ParameterSetDescription desc1 = desc;
     edm::ParameterSetDescription desc2 = desc;
     desc1.add<bool>("applyWeight", false);
     desc1.add<edm::InputTag>("srcWeights", edm::InputTag(""));
     descriptions.add("pfMet", desc1);
     desc2.add<bool>("applyWeight", true);
     desc2.add<edm::InputTag>("srcWeights", edm::InputTag("puppiNoLep"));
     descriptions.add("pfMetPuppi", desc2);
   }

◆ getMETCovMatrix()

reco::METCovMatrix PFMETProducer::getMETCovMatrix	(	const edm::Event &	event,
		const edm::EventSetup &	setup,
		const edm::Handle< edm::View< reco::Candidate >> &	input
	)		const

private

Definition at line 86 of file PFMETProducer.cc.

References metsig::METSignificance::getCovariance(), HLT_2024v14_cff::inputJets, jetResPhiToken_, jetResPtToken_, jetSFToken_, jetToken_, lepTokens_, HLT_2024v14_cff::leptons, metSigAlgo_, rhoToken_, singleTopDQM_cfi::setup, met_cff::sumPtUnclustered, trackerHitRTTI::vector, and weights_.

Referenced by produce().

                                                                                                               {
     // leptons
     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);
       /*
       for ( reco::CandidateView::const_iterator lepton = leptons_i->begin();
         lepton != leptons_i->end(); ++lepton ) {
         leptons.push_back(*lepton);
       }
      */
     }
 
     // jets
     edm::Handle<edm::View<reco::Jet>> inputJets;
     event.getByToken(jetToken_, inputJets);
 
     JME::JetResolution resPtObj(setup.getData(jetResPtToken_));
     JME::JetResolution resPhiObj(setup.getData(jetResPhiToken_));
     JME::JetResolutionScaleFactor resSFObj(setup.getData(jetSFToken_));
 
     edm::Handle<double> rho;
     event.getByToken(rhoToken_, rho);
 
     //Compute the covariance matrix and fill it
     double sumPtUnclustered = 0;
     reco::METCovMatrix cov = metSigAlgo_->getCovariance(*inputJets,
                                                         leptons,
                                                         candInput,
                                                         *rho,
                                                         resPtObj,
                                                         resPhiObj,
                                                         resSFObj,
                                                         event.isRealData(),
                                                         sumPtUnclustered,
                                                         weights_);
 
     return cov;
   }

◆ produce()

void PFMETProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Definition at line 54 of file PFMETProducer.cc.

References applyWeight_, calculateSignificance_, edm::ValueMap< T >::get(), getMETCovMatrix(), globalThreshold_, input, inputToken_, CommonMETData::met, CommonMETData::mex, CommonMETData::mey, eostools::move(), packedPFCandidateRefMixer_cfi::pf, reco::MET::setIsWeighted(), reco::MET::setSignificanceMatrix(), singleTopDQM_cfi::setup, timingPdfMaker::specific, CommonMETData::sumet, L1BJetProducer_cff::vtx, weights_, and weightsToken_.

                                                                          {
     edm::Handle<edm::View<reco::Candidate>> input;
     event.getByToken(inputToken_, input);
 
     if (applyWeight_)
       weights_ = &event.get(weightsToken_);
 
     METAlgo algo;
     CommonMETData commonMETdata;
     commonMETdata = algo.run(*input.product(), globalThreshold_, weights_);
 
     const math::XYZTLorentzVector p4(commonMETdata.mex, commonMETdata.mey, 0.0, commonMETdata.met);
     const math::XYZPoint vtx(0.0, 0.0, 0.0);
 
     PFSpecificAlgo pf;
     SpecificPFMETData specific;
     specific = pf.run(*input.product(), weights_);
 
     reco::PFMET pfmet(specific, commonMETdata.sumet, p4, vtx);
     pfmet.setIsWeighted(applyWeight_);
 
     if (calculateSignificance_) {
       reco::METCovMatrix sigcov = getMETCovMatrix(event, setup, input);
       pfmet.setSignificanceMatrix(sigcov);
     }
 
     auto pfmetcoll = std::make_unique<reco::PFMETCollection>();
 
     pfmetcoll->push_back(pfmet);
     event.put(std::move(pfmetcoll));
   }