#include <METSignificanceProducer.h>

Inheritance diagram for cms::METSignificanceProducer:

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

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

	~METSignificanceProducer () 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 Attributes
std::string	jetResPhiType_

JME::JetResolution::Token	jetResPhiTypeToken_

std::string	jetResPtType_

JME::JetResolution::Token	jetResPtTypeToken_

std::string	jetSFType_

JME::JetResolutionScaleFactor::Token	jetSFTypeToken_

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

metsig::METSignificance *	metSigAlgo_

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

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

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

edm::EDGetTokenT< double >	rhoToken_

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 46 of file METSignificanceProducer.h.

Constructor & Destructor Documentation

◆ METSignificanceProducer()

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

explicit

Definition at line 15 of file METSignificanceProducer.cc.

References deDxTools::esConsumes(), edm::ParameterSet::getParameter(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, jetResPhiType_, jetResPhiTypeToken_, jetResPtType_, jetResPtTypeToken_, jetSFType_, jetSFTypeToken_, lepTokens_, metSigAlgo_, METSignificance_cfi::METSignificance, metToken_, pfCandidatesToken_, pfjetsToken_, rhoToken_, HLT_2023v12_cff::srcWeights, AlCaHLTBitMon_QueryRunRegistry::string, and weightsToken_.

                                                                                  {
     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));
     }
 
     pfjetsToken_ = consumes<edm::View<reco::Jet>>(iConfig.getParameter<edm::InputTag>("srcPfJets"));
 
     metToken_ = consumes<edm::View<reco::MET>>(iConfig.getParameter<edm::InputTag>("srcMet"));
     pfCandidatesToken_ = consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("srcPFCandidates"));
 
     jetSFType_ = iConfig.getParameter<std::string>("srcJetSF");
     jetResPtType_ = iConfig.getParameter<std::string>("srcJetResPt");
     jetResPhiType_ = iConfig.getParameter<std::string>("srcJetResPhi");
     jetSFTypeToken_ = esConsumes(edm::ESInputTag("", jetSFType_));
     jetResPtTypeToken_ = esConsumes(edm::ESInputTag("", jetResPtType_));
     jetResPhiTypeToken_ = esConsumes(edm::ESInputTag("", jetResPhiType_));
     rhoToken_ = consumes<double>(iConfig.getParameter<edm::InputTag>("srcRho"));
 
     edm::InputTag srcWeights = iConfig.getParameter<edm::InputTag>("srcWeights");
     if (!srcWeights.label().empty())
       weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);
 
     metSigAlgo_ = new metsig::METSignificance(iConfig);
 
     produces<double>("METSignificance");
     produces<math::Error<2>::type>("METCovariance");
   }

◆ ~METSignificanceProducer()

METSignificanceProducer::~METSignificanceProducer ( )

override

Definition at line 44 of file METSignificanceProducer.cc.

References metSigAlgo_.

44 { delete metSigAlgo_; }

cms::METSignificanceProducer::metSigAlgo_

metsig::METSignificance * metSigAlgo_

Definition: METSignificanceProducer.h:68

Member Function Documentation

◆ produce()

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

override

Definition at line 47 of file METSignificanceProducer.cc.

References JME::JetResolution::get(), JME::JetResolutionScaleFactor::get(), metsig::METSignificance::getCovariance(), metsig::METSignificance::getSignificance(), edm::EDGetTokenT< T >::isUninitialized(), jetResPhiTypeToken_, jetResPtTypeToken_, PDWG_EXODelayedJetMET_cff::jets, jetSFTypeToken_, lepTokens_, HLT_2023v12_cff::leptons, BTaggingMonitor_cfi::met, metSigAlgo_, metToken_, eostools::move(), zmumugammaAnalyzer_cfi::pfCandidates, pfCandidatesToken_, pfjetsToken_, rhoToken_, singleTopDQM_cfi::setup, met_cff::significance, met_cff::sumPtUnclustered, trackerHitRTTI::vector, hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights, and weightsToken_.

                                                                                    {
     //
     // met
     //
     edm::Handle<edm::View<reco::MET>> metHandle;
     event.getByToken(metToken_, metHandle);
     const reco::MET& met = (*metHandle)[0];
 
     //
     // candidates
     //
     edm::Handle<reco::CandidateView> pfCandidates;
     event.getByToken(pfCandidatesToken_, pfCandidates);
 
     //
     // 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);
     }
 
     //
     // jets
     //
     edm::Handle<edm::View<reco::Jet>> jets;
     event.getByToken(pfjetsToken_, jets);
 
     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(setup, jetResPtTypeToken_);
     JME::JetResolution resPhiObj = JME::JetResolution::get(setup, jetResPhiTypeToken_);
     JME::JetResolutionScaleFactor resSFObj = JME::JetResolutionScaleFactor::get(setup, jetSFTypeToken_);
 
     //
     // compute the significance
     //
     double sumPtUnclustered = 0;
     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 METSignificanceProducer\n";
       weightsPtr = &*weights;
     }
     reco::METCovMatrix cov = metSigAlgo_->getCovariance(*jets,
                                                         leptons,
                                                         pfCandidates,
                                                         *rho,
                                                         resPtObj,
                                                         resPhiObj,
                                                         resSFObj,
                                                         event.isRealData(),
                                                         sumPtUnclustered,
                                                         weightsPtr);
     double sig = metSigAlgo_->getSignificance(cov, met);
 
     auto significance = std::make_unique<double>();
     (*significance) = sig;
 
     auto covPtr = std::make_unique<math::Error<2>::type>();
     (*covPtr)(0, 0) = cov(0, 0);
     (*covPtr)(1, 0) = cov(1, 0);
     (*covPtr)(1, 1) = cov(1, 1);
 
     event.put(std::move(covPtr), "METCovariance");
     event.put(std::move(significance), "METSignificance");
   }