NoPileUpPFMEtProducer Class Reference

#include <NoPileUpPFMEtProducer.h>

Inheritance diagram for NoPileUpPFMEtProducer:

Public Member Functions
	NoPileUpPFMEtProducer (const edm::ParameterSet &)
	~NoPileUpPFMEtProducer () 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::string	moduleLabel_
PFMEtSignInterfaceBase *	pfMEtSignInterface_
bool	saveInputs_
double	sfLeptonIsoCones_
std::string	sfLeptonIsoConesName_
std::string	sfLeptonsName_
double	sfMEtCovMax_
double	sfMEtCovMin_
double	sfNoPUjetOffsetEnCorr_
std::string	sfNoPUjetOffsetEnCorrName_
double	sfNoPUjets_
std::string	sfNoPUjetsName_
double	sfNoPUunclChargedCands_
std::string	sfNoPUunclChargedCandsName_
double	sfPUjets_
std::string	sfPUjetsName_
double	sfPUunclChargedCands_
std::string	sfPUunclChargedCandsName_
double	sfType0Correction_
std::string	sfType0CorrectionName_
double	sfUnclNeutralCands_
std::string	sfUnclNeutralCandsName_
edm::EDGetTokenT< reco::PUSubMETCandInfoCollection >	srcJetInfo_
edm::EDGetTokenT< reco::PUSubMETCandInfoCollection >	srcJetInfoLeptonMatch_
std::vector< edm::EDGetTokenT< reco::CandidateView > >	srcLeptons_
edm::EDGetTokenT< reco::PFMETCollection >	srcMEt_
edm::InputTag	srcMEtCov_
edm::EDGetTokenT< reco::PUSubMETCandInfoCollection >	srcPFCandInfo_
edm::EDGetTokenT< reco::PUSubMETCandInfoCollection >	srcPFCandInfoLeptonMatch_
edm::EDGetTokenT< CorrMETData >	srcType0Correction_
NoPileUpMEtUtilities	utils_
int	verbosity_

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

Produce PFMET objects from no-PU jets + "unclustered" no-PU tracks + "unclustered" neutral particles ("unclustered" particles = particles not within jets)

Authors

Christian Veelken, LLR

Definition at line 30 of file NoPileUpPFMEtProducer.h.

Member Typedef Documentation

vInputTag

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

private

Definition at line 46 of file NoPileUpPFMEtProducer.h.

Constructor & Destructor Documentation

NoPileUpPFMEtProducer()

NoPileUpPFMEtProducer::NoPileUpPFMEtProducer

(

const edm::ParameterSet &

cfg

)

Definition at line 16 of file NoPileUpPFMEtProducer.cc.

References looper::cfg, ProducerED_cfi::InputTag, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, pfMEtSignInterface_, saveInputs_, sfLeptonIsoCones_, sfLeptonIsoConesName_, sfLeptonsName_, sfMEtCovMax_, sfMEtCovMin_, sfNoPUjetOffsetEnCorr_, sfNoPUjetOffsetEnCorrName_, sfNoPUjets_, sfNoPUjetsName_, sfNoPUunclChargedCands_, sfNoPUunclChargedCandsName_, sfPUjets_, sfPUjetsName_, sfPUunclChargedCands_, sfPUunclChargedCandsName_, sfType0Correction_, sfType0CorrectionName_, sfUnclNeutralCands_, sfUnclNeutralCandsName_, srcJetInfo_, srcJetInfoLeptonMatch_, srcLeptons_, srcMEt_, srcMEtCov_, srcPFCandInfo_, srcPFCandInfoLeptonMatch_, srcType0Correction_, and verbosity_.

    : moduleLabel_(cfg.getParameter<std::string>("@module_label")) {
  srcMEt_ = consumes<reco::PFMETCollection>(cfg.getParameter<edm::InputTag>("srcMEt"));
  srcMEtCov_ = edm::InputTag();  //MM, disabled for the moment until we really need it
  //( cfg.exists("srcMEtCov") ) ?
  //  consumes<edm::Handle<> >(cfg.getParameter<edm::InputTag>("srcMEtCov")) : edm::InputTag();
  srcJetInfo_ = consumes<reco::PUSubMETCandInfoCollection>(cfg.getParameter<edm::InputTag>("srcPUSubMETDataJet"));
  srcJetInfoLeptonMatch_ =
      consumes<reco::PUSubMETCandInfoCollection>(cfg.getParameter<edm::InputTag>("srcPUSubMETDataJetLeptonMatch"));
  srcPFCandInfo_ =
      consumes<reco::PUSubMETCandInfoCollection>(cfg.getParameter<edm::InputTag>("srcPUSubMETDataPFCands"));
  srcPFCandInfoLeptonMatch_ =
      consumes<reco::PUSubMETCandInfoCollection>(cfg.getParameter<edm::InputTag>("srcPUSubMETDataPFCandsLeptonMatch"));
  vInputTag srcLeptonsTags = cfg.getParameter<vInputTag>("srcLeptons");
  for (vInputTag::const_iterator it = srcLeptonsTags.begin(); it != srcLeptonsTags.end(); it++) {
    srcLeptons_.push_back(consumes<edm::View<reco::Candidate> >(*it));
  }

  srcType0Correction_ = consumes<CorrMETData>(cfg.getParameter<edm::InputTag>("srcType0Correction"));

  sfNoPUjets_ = cfg.getParameter<double>("sfNoPUjets");
  sfNoPUjetOffsetEnCorr_ = cfg.getParameter<double>("sfNoPUjetOffsetEnCorr");
  sfPUjets_ = cfg.getParameter<double>("sfPUjets");
  sfNoPUunclChargedCands_ = cfg.getParameter<double>("sfNoPUunclChargedCands");
  sfPUunclChargedCands_ = cfg.getParameter<double>("sfPUunclChargedCands");
  sfUnclNeutralCands_ = cfg.getParameter<double>("sfUnclNeutralCands");
  sfType0Correction_ = cfg.getParameter<double>("sfType0Correction");
  sfLeptonIsoCones_ = cfg.getParameter<double>("sfLeptonIsoCones");

  pfMEtSignInterface_ = new PFMEtSignInterfaceBase(cfg.getParameter<edm::ParameterSet>("resolution"));
  sfMEtCovMin_ = cfg.getParameter<double>("sfMEtCovMin");
  sfMEtCovMax_ = cfg.getParameter<double>("sfMEtCovMax");

  saveInputs_ = (cfg.exists("saveInputs")) ? cfg.getParameter<bool>("saveInputs") : false;

  verbosity_ = (cfg.exists("verbosity")) ? cfg.getParameter<int>("verbosity") : 0;

  produces<reco::PFMETCollection>();

  sfLeptonsName_ = "sumLeptons";
  sfNoPUjetsName_ = "sumNoPUjets";
  sfNoPUjetOffsetEnCorrName_ = "sumNoPUjetOffsetEnCorr";
  sfPUjetsName_ = "sumPUjets";
  sfNoPUunclChargedCandsName_ = "sumNoPUunclChargedCands";
  sfPUunclChargedCandsName_ = "sumPUunclChargedCands";
  sfUnclNeutralCandsName_ = "sumUnclNeutralCands";
  sfType0CorrectionName_ = "type0Correction";
  sfLeptonIsoConesName_ = "sumLeptonIsoCones";

  if (saveInputs_) {
    produces<CommonMETData>(sfLeptonsName_);
    produces<CommonMETData>(sfNoPUjetsName_);
    produces<CommonMETData>(sfNoPUjetOffsetEnCorrName_);
    produces<CommonMETData>(sfPUjetsName_);
    produces<CommonMETData>(sfNoPUunclChargedCandsName_);
    produces<CommonMETData>(sfPUunclChargedCandsName_);
    produces<CommonMETData>(sfUnclNeutralCandsName_);
    produces<CommonMETData>(sfType0CorrectionName_);
    produces<CommonMETData>(sfLeptonIsoConesName_);
  }
  produces<double>("sfNoPU");
}

~NoPileUpPFMEtProducer()

NoPileUpPFMEtProducer::~NoPileUpPFMEtProducer ( )

override

Definition at line 79 of file NoPileUpPFMEtProducer.cc.

References pfMEtSignInterface_.

{ delete pfMEtSignInterface_; }

Member Function Documentation

produce()

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

overrideprivate

Definition at line 206 of file NoPileUpPFMEtProducer.cc.

References funct::abs(), addToCommonMETData(), cms::cuda::assert(), edm::View< T >::begin(), NoPileUpMEtUtilities::cleanJets(), NoPileUpMEtUtilities::cleanPFCandidates(), PFMEtSignInterfaceBase::compResolution(), computePFMEtSignificance(), HLTMuonOfflineAnalyzer_cfi::deltaR2, ALPAKA_ACCELERATOR_NAMESPACE::dR2(), edm::View< T >::end(), Exception, finalizeCommonMETData(), findBestMatchingLepton(), edm::Event::getByToken(), reco::MET::getSignificanceMatrix(), initializeCommonMETData(), metsig::jet, PDWG_EXODelayedJetMET_cff::jets, reco::PUSubMETCandInfo::kChHS, reco::PUSubMETCandInfo::kChPU, reco::PUSubMETCandInfo::kHS, reco::PUSubMETCandInfo::kNeutral, edm::InputTag::label(), HLT_2023v12_cff::leptons, LogDebug, CorrMETData::mex, CorrMETData::mey, moduleLabel_, eostools::move(), zmumugammaAnalyzer_cfi::pfCandidates, pfMEtSignInterface_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), edm::Event::put(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), saveInputs_, scaleAndAddPFMEtSignObjects(), reco::LeafCandidate::setP4(), reco::MET::setSignificanceMatrix(), sfLeptonIsoCones_, sfLeptonIsoConesName_, sfLeptonsName_, sfMEtCovMax_, sfMEtCovMin_, sfNoPUjetOffsetEnCorr_, sfNoPUjetOffsetEnCorrName_, sfNoPUjets_, sfNoPUjetsName_, sfNoPUunclChargedCands_, sfNoPUunclChargedCandsName_, sfPUjets_, sfPUjetsName_, sfPUunclChargedCands_, sfPUunclChargedCandsName_, sfType0Correction_, sfType0CorrectionName_, sfUnclNeutralCands_, sfUnclNeutralCandsName_, mathSSE::sqrt(), srcJetInfo_, srcJetInfoLeptonMatch_, srcLeptons_, srcMEt_, srcMEtCov_, srcPFCandInfo_, srcPFCandInfoLeptonMatch_, srcType0Correction_, utils_, and trackerHitRTTI::vector.

                                                                          {
  LogDebug("produce") << " moduleLabel = " << moduleLabel_ << std::endl;

  // get original MET
  edm::Handle<reco::PFMETCollection> pfMETs;
  evt.getByToken(srcMEt_, pfMETs);
  if (!(pfMETs->size() == 1))
    throw cms::Exception("NoPileUpPFMEtProducer::produce") << "Failed to find unique MET object !!\n";
  const reco::PFMET& pfMEt_original = pfMETs->front();

  // get MET covariance matrix
  reco::METCovMatrix pfMEtCov;
  if (!srcMEtCov_.label().empty()) {
    //MM manual bypass to pfMET as this case has neer been presented
    // edm::Handle<PFMEtSignCovMatrix> pfMEtCovHandle;
    // evt.getByToken(srcMEtCov_, pfMEtCovHandle);
    // pfMEtCov = (*pfMEtCovHandle);
    pfMEtCov = pfMEt_original.getSignificanceMatrix();
  } else {
    pfMEtCov = pfMEt_original.getSignificanceMatrix();
  }

  // get lepton momenta
  std::vector<reco::Candidate::LorentzVector> leptons;
  std::vector<metsig::SigInputObj> metSignObjectsLeptons;
  reco::Candidate::LorentzVector sumLeptonP4s;
  for (std::vector<edm::EDGetTokenT<edm::View<reco::Candidate> > >::const_iterator srcLeptons_i = srcLeptons_.begin();
       srcLeptons_i != srcLeptons_.end();
       ++srcLeptons_i) {
    edm::Handle<reco::CandidateView> leptons_i;
    evt.getByToken(*srcLeptons_i, leptons_i);
    for (reco::CandidateView::const_iterator lepton = leptons_i->begin(); lepton != leptons_i->end(); ++lepton) {
      leptons.push_back(lepton->p4());
      metSignObjectsLeptons.push_back(pfMEtSignInterface_->compResolution(&(*lepton)));
      sumLeptonP4s += lepton->p4();
    }
  }
  LogDebug("produce") << " sum(leptons): Pt = " << sumLeptonP4s.pt() << ", eta = " << sumLeptonP4s.eta()
                      << ", phi = " << sumLeptonP4s.phi() << ","
                      << " mass = " << sumLeptonP4s.mass() << std::endl;

  // get jet and PFCandidate information
  edm::Handle<reco::PUSubMETCandInfoCollection> jets;
  evt.getByToken(srcJetInfo_, jets);
  edm::Handle<reco::PUSubMETCandInfoCollection> jetsLeptonMatch;
  evt.getByToken(srcJetInfoLeptonMatch_, jetsLeptonMatch);
  edm::Handle<reco::PUSubMETCandInfoCollection> pfCandidates;
  evt.getByToken(srcPFCandInfo_, pfCandidates);
  edm::Handle<reco::PUSubMETCandInfoCollection> pfCandidatesLeptonMatch;
  evt.getByToken(srcPFCandInfoLeptonMatch_, pfCandidatesLeptonMatch);

  reco::PUSubMETCandInfoCollection jets_leptons = utils_.cleanJets(*jetsLeptonMatch, leptons, 0.5, true);
  reco::PUSubMETCandInfoCollection pfCandidates_leptons =
      utils_.cleanPFCandidates(*pfCandidatesLeptonMatch, leptons, 0.3, true);
  std::vector<CommonMETData> sumJetsPlusPFCandidates_leptons(leptons.size());
  for (std::vector<CommonMETData>::iterator sumJetsPlusPFCandidates = sumJetsPlusPFCandidates_leptons.begin();
       sumJetsPlusPFCandidates != sumJetsPlusPFCandidates_leptons.end();
       ++sumJetsPlusPFCandidates) {
    initializeCommonMETData(*sumJetsPlusPFCandidates);
  }
  for (reco::PUSubMETCandInfoCollection::const_iterator jet = jets_leptons.begin(); jet != jets_leptons.end(); ++jet) {
    int leptonIdx_dRmin = findBestMatchingLepton(leptons, jet->p4());
    assert(leptonIdx_dRmin >= 0 && leptonIdx_dRmin < (int)sumJetsPlusPFCandidates_leptons.size());

    LogDebug("produce") << "jet-to-lepton match:"
                        << " jetPt = " << jet->p4().pt() << ", jetEta = " << jet->p4().eta()
                        << ", jetPhi = " << jet->p4().phi() << " leptonPt = " << leptons[leptonIdx_dRmin].pt()
                        << ", leptonEta = " << leptons[leptonIdx_dRmin].eta()
                        << ", leptonPhi = " << leptons[leptonIdx_dRmin].phi() << std::endl;

    sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].mex += jet->p4().px();
    sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].mey += jet->p4().py();
    sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].sumet += jet->p4().pt();
  }
  for (reco::PUSubMETCandInfoCollection::const_iterator pfCandidate = pfCandidates_leptons.begin();
       pfCandidate != pfCandidates_leptons.end();
       ++pfCandidate) {
    bool isWithinJet_lepton = false;
    if (pfCandidate->isWithinJet()) {
      for (reco::PUSubMETCandInfoCollection::const_iterator jet = jets_leptons.begin(); jet != jets_leptons.end();
           ++jet) {
        double dR2 = deltaR2(pfCandidate->p4(), jet->p4());
        if (dR2 < 0.5 * 0.5)
          isWithinJet_lepton = true;
      }
    }
    if (!isWithinJet_lepton) {
      int leptonIdx_dRmin = findBestMatchingLepton(leptons, pfCandidate->p4());
      assert(leptonIdx_dRmin >= 0 && leptonIdx_dRmin < (int)sumJetsPlusPFCandidates_leptons.size());
      LogDebug("produce") << "pfCandidate-to-lepton match:"
                          << " pfCandidatePt = " << pfCandidate->p4().pt()
                          << ", pfCandidateEta = " << pfCandidate->p4().eta()
                          << ", pfCandidatePhi = " << pfCandidate->p4().phi()
                          << " leptonPt = " << leptons[leptonIdx_dRmin].pt()
                          << ", leptonEta = " << leptons[leptonIdx_dRmin].eta()
                          << ", leptonPhi = " << leptons[leptonIdx_dRmin].phi() << std::endl;

      sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].mex += pfCandidate->p4().px();
      sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].mey += pfCandidate->p4().py();
      sumJetsPlusPFCandidates_leptons[leptonIdx_dRmin].sumet += pfCandidate->p4().pt();
    } else {
      LogDebug("produce") << " pfCandidate is within jet --> skipping." << std::endl;
    }
  }
  auto sumLeptons = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumLeptons);
  auto sumLeptonIsoCones = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumLeptonIsoCones);
  int leptonIdx = 0;
  for (std::vector<CommonMETData>::iterator sumJetsPlusPFCandidates = sumJetsPlusPFCandidates_leptons.begin();
       sumJetsPlusPFCandidates != sumJetsPlusPFCandidates_leptons.end();
       ++sumJetsPlusPFCandidates) {
    if (sumJetsPlusPFCandidates->sumet > leptons[leptonIdx].pt()) {
      double leptonEnFrac = leptons[leptonIdx].pt() / sumJetsPlusPFCandidates->sumet;
      assert(leptonEnFrac >= 0.0 && leptonEnFrac <= 1.0);
      sumLeptons->mex += (leptonEnFrac * sumJetsPlusPFCandidates->mex);
      sumLeptons->mey += (leptonEnFrac * sumJetsPlusPFCandidates->mey);
      sumLeptons->sumet += (leptonEnFrac * sumJetsPlusPFCandidates->sumet);
      double leptonIsoConeEnFrac = 1.0 - leptonEnFrac;
      assert(leptonIsoConeEnFrac >= 0.0 && leptonIsoConeEnFrac <= 1.0);
      sumLeptonIsoCones->mex += (leptonIsoConeEnFrac * sumJetsPlusPFCandidates->mex);
      sumLeptonIsoCones->mey += (leptonIsoConeEnFrac * sumJetsPlusPFCandidates->mey);
      sumLeptonIsoCones->sumet += (leptonIsoConeEnFrac * sumJetsPlusPFCandidates->sumet);
    } else {
      sumLeptons->mex += sumJetsPlusPFCandidates->mex;
      sumLeptons->mey += sumJetsPlusPFCandidates->mey;
      sumLeptons->sumet += sumJetsPlusPFCandidates->sumet;
    }
    ++leptonIdx;
  }

  reco::PUSubMETCandInfoCollection jets_cleaned = utils_.cleanJets(*jets, leptons, 0.5, false);
  reco::PUSubMETCandInfoCollection pfCandidates_cleaned = utils_.cleanPFCandidates(*pfCandidates, leptons, 0.3, false);

  auto sumNoPUjets = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumNoPUjets);
  std::vector<metsig::SigInputObj> metSignObjectsNoPUjets;
  auto sumNoPUjetOffsetEnCorr = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumNoPUjetOffsetEnCorr);
  std::vector<metsig::SigInputObj> metSignObjectsNoPUjetOffsetEnCorr;
  auto sumPUjets = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumPUjets);
  std::vector<metsig::SigInputObj> metSignObjectsPUjets;
  for (reco::PUSubMETCandInfoCollection::const_iterator jet = jets_cleaned.begin(); jet != jets_cleaned.end(); ++jet) {
    if (jet->passesLooseJetId()) {
      if (jet->type() == reco::PUSubMETCandInfo::kHS) {
        addToCommonMETData(*sumNoPUjets, jet->p4());
        metSignObjectsNoPUjets.push_back(jet->metSignObj());
        float jetp = jet->p4().P();
        float jetcorr = jet->offsetEnCorr();
        sumNoPUjetOffsetEnCorr->mex += jetcorr * jet->p4().px() / jetp;
        sumNoPUjetOffsetEnCorr->mey += jetcorr * jet->p4().py() / jetp;
        sumNoPUjetOffsetEnCorr->mez += jetcorr * jet->p4().pz() / jetp;
        sumNoPUjetOffsetEnCorr->sumet += jetcorr * jet->p4().pt() / jetp;
        metsig::SigInputObj pfMEtSignObjectOffsetEnCorr(
            jet->metSignObj().get_type(),
            jet->offsetEnCorr(),
            jet->metSignObj().get_phi(),
            (jet->offsetEnCorr() / jet->p4().E()) * jet->metSignObj().get_sigma_e(),
            jet->metSignObj().get_sigma_tan());
        metSignObjectsNoPUjetOffsetEnCorr.push_back(pfMEtSignObjectOffsetEnCorr);
      } else {
        addToCommonMETData(*sumPUjets, jet->p4());
        metSignObjectsPUjets.push_back(jet->metSignObj());
      }
    }
  }

  auto sumNoPUunclChargedCands = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumNoPUunclChargedCands);
  std::vector<metsig::SigInputObj> metSignObjectsNoPUunclChargedCands;
  auto sumPUunclChargedCands = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumPUunclChargedCands);
  std::vector<metsig::SigInputObj> metSignObjectsPUunclChargedCands;
  auto sumUnclNeutralCands = std::make_unique<CommonMETData>();
  initializeCommonMETData(*sumUnclNeutralCands);
  std::vector<metsig::SigInputObj> metSignObjectsUnclNeutralCands;
  for (reco::PUSubMETCandInfoCollection::const_iterator pfCandidate = pfCandidates_cleaned.begin();
       pfCandidate != pfCandidates_cleaned.end();
       ++pfCandidate) {
    if (pfCandidate->passesLooseJetId()) {
      if (!pfCandidate->isWithinJet()) {
        if (pfCandidate->type() == reco::PUSubMETCandInfo::kChHS) {
          addToCommonMETData(*sumNoPUunclChargedCands, pfCandidate->p4());
          metSignObjectsNoPUunclChargedCands.push_back(pfCandidate->metSignObj());
        } else if (pfCandidate->type() == reco::PUSubMETCandInfo::kChPU) {
          addToCommonMETData(*sumPUunclChargedCands, pfCandidate->p4());
          metSignObjectsPUunclChargedCands.push_back(pfCandidate->metSignObj());
        } else if (pfCandidate->type() == reco::PUSubMETCandInfo::kNeutral) {
          addToCommonMETData(*sumUnclNeutralCands, pfCandidate->p4());
          metSignObjectsUnclNeutralCands.push_back(pfCandidate->metSignObj());
        }
      }
    }
  }

  edm::Handle<CorrMETData> type0Correction_input;
  evt.getByToken(srcType0Correction_, type0Correction_input);
  auto type0Correction_output = std::make_unique<CommonMETData>();
  initializeCommonMETData(*type0Correction_output);
  type0Correction_output->mex = type0Correction_input->mex;
  type0Correction_output->mey = type0Correction_input->mey;

  finalizeCommonMETData(*sumLeptons);
  finalizeCommonMETData(*sumNoPUjetOffsetEnCorr);
  finalizeCommonMETData(*sumNoPUjets);
  finalizeCommonMETData(*sumPUjets);
  finalizeCommonMETData(*sumNoPUunclChargedCands);
  finalizeCommonMETData(*sumPUunclChargedCands);
  finalizeCommonMETData(*sumUnclNeutralCands);
  finalizeCommonMETData(*type0Correction_output);
  finalizeCommonMETData(*sumLeptonIsoCones);

  double noPileUpScaleFactor =
      (sumPUunclChargedCands->sumet > 0.)
          ? (sumPUunclChargedCands->sumet / (sumNoPUunclChargedCands->sumet + sumPUunclChargedCands->sumet))
          : 1.;
  LogDebug("produce") << "noPileUpScaleFactor = " << noPileUpScaleFactor << std::endl;

  double noPileUpMEtPx =
      -(sumLeptons->mex + sumNoPUjets->mex + sumNoPUunclChargedCands->mex +
        noPileUpScaleFactor *
            (sfNoPUjetOffsetEnCorr_ * sumNoPUjetOffsetEnCorr->mex + sfUnclNeutralCands_ * sumUnclNeutralCands->mex +
             sfPUunclChargedCands_ * sumPUunclChargedCands->mex + sfPUjets_ * sumPUjets->mex)) +
      noPileUpScaleFactor * sfType0Correction_ * type0Correction_output->mex;
  if (sfLeptonIsoCones_ >= 0.)
    noPileUpMEtPx -= (noPileUpScaleFactor * sfLeptonIsoCones_ * sumLeptonIsoCones->mex);
  else
    noPileUpMEtPx -= (std::abs(sfLeptonIsoCones_) * sumLeptonIsoCones->mex);
  double noPileUpMEtPy =
      -(sumLeptons->mey + sumNoPUjets->mey + sumNoPUunclChargedCands->mey +
        noPileUpScaleFactor *
            (sfNoPUjetOffsetEnCorr_ * sumNoPUjetOffsetEnCorr->mey + sfUnclNeutralCands_ * sumUnclNeutralCands->mey +
             sfPUunclChargedCands_ * sumPUunclChargedCands->mey + sfPUjets_ * sumPUjets->mey)) +
      noPileUpScaleFactor * sfType0Correction_ * type0Correction_output->mey;
  if (sfLeptonIsoCones_ >= 0.)
    noPileUpMEtPy -= (noPileUpScaleFactor * sfLeptonIsoCones_ * sumLeptonIsoCones->mey);
  else
    noPileUpMEtPy -= (std::abs(sfLeptonIsoCones_) * sumLeptonIsoCones->mey);
  double noPileUpMEtPt = sqrt(noPileUpMEtPx * noPileUpMEtPx + noPileUpMEtPy * noPileUpMEtPy);
  reco::Candidate::LorentzVector noPileUpMEtP4(noPileUpMEtPx, noPileUpMEtPy, 0., noPileUpMEtPt);

  reco::PFMET noPileUpMEt(pfMEt_original);
  noPileUpMEt.setP4(noPileUpMEtP4);
  //noPileUpMEt.setSignificanceMatrix(pfMEtCov);

  std::vector<metsig::SigInputObj> metSignObjects_scaled;
  scaleAndAddPFMEtSignObjects(metSignObjects_scaled, metSignObjectsLeptons, 1.0, sfMEtCovMin_, sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(
      metSignObjects_scaled, metSignObjectsNoPUjetOffsetEnCorr, sfNoPUjetOffsetEnCorr_, sfMEtCovMin_, sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(metSignObjects_scaled, metSignObjectsNoPUjets, sfNoPUjets_, sfMEtCovMin_, sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(
      metSignObjects_scaled, metSignObjectsPUjets, noPileUpScaleFactor * sfPUjets_, sfMEtCovMin_, sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(
      metSignObjects_scaled, metSignObjectsNoPUunclChargedCands, sfNoPUunclChargedCands_, sfMEtCovMin_, sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(metSignObjects_scaled,
                              metSignObjectsPUunclChargedCands,
                              noPileUpScaleFactor * sfPUunclChargedCands_,
                              sfMEtCovMin_,
                              sfMEtCovMax_);
  scaleAndAddPFMEtSignObjects(metSignObjects_scaled,
                              metSignObjectsUnclNeutralCands,
                              noPileUpScaleFactor * sfUnclNeutralCands_,
                              sfMEtCovMin_,
                              sfMEtCovMax_);
  reco::METCovMatrix pfMEtCov_recomputed = computePFMEtSignificance(metSignObjects_scaled);
  noPileUpMEt.setSignificanceMatrix(pfMEtCov_recomputed);

  LogDebug("produce") << "<NoPileUpPFMEtProducer::produce>:" << std::endl
                      << " moduleLabel = " << moduleLabel_ << std::endl
                      << " PFMET: Pt = " << pfMEt_original.pt() << ", phi = " << pfMEt_original.phi() << " "
                      << "(Px = " << pfMEt_original.px() << ", Py = " << pfMEt_original.py() << ")" << std::endl
                      << " Cov:" << std::endl
                      << " " << pfMEtCov(0, 0) << "  " << pfMEtCov(0, 1) << "\n " << pfMEtCov(1, 0) << "  "
                      << pfMEtCov(1, 1) << std::endl
                      << " no-PU MET: Pt = " << noPileUpMEt.pt() << ", phi = " << noPileUpMEt.phi() << " "
                      << "(Px = " << noPileUpMEt.px() << ", Py = " << noPileUpMEt.py() << ")" << std::endl
                      << " Cov:" << std::endl
                      << " " << (noPileUpMEt.getSignificanceMatrix())(0, 0) << "  "
                      << (noPileUpMEt.getSignificanceMatrix())(0, 1) << std::endl
                      << (noPileUpMEt.getSignificanceMatrix())(1, 0) << "  "
                      << (noPileUpMEt.getSignificanceMatrix())(1, 1) << std::endl;

  // add no-PU MET object to the event
  auto noPileUpMEtCollection = std::make_unique<reco::PFMETCollection>();
  noPileUpMEtCollection->push_back(noPileUpMEt);

  evt.put(std::move(noPileUpMEtCollection));
  if (saveInputs_) {
    evt.put(std::move(sumLeptons), sfLeptonsName_);
    evt.put(std::move(sumNoPUjetOffsetEnCorr), sfNoPUjetOffsetEnCorrName_);
    evt.put(std::move(sumNoPUjets), sfNoPUjetsName_);
    evt.put(std::move(sumPUjets), sfPUjetsName_);
    evt.put(std::move(sumNoPUunclChargedCands), sfNoPUunclChargedCandsName_);
    evt.put(std::move(sumPUunclChargedCands), sfPUunclChargedCandsName_);
    evt.put(std::move(sumUnclNeutralCands), sfUnclNeutralCandsName_);
    evt.put(std::move(type0Correction_output), sfType0CorrectionName_);
    evt.put(std::move(sumLeptonIsoCones), sfLeptonIsoConesName_);
  }

  evt.put(std::make_unique<double>(noPileUpScaleFactor), "sfNoPU");
}

Member Data Documentation

moduleLabel_

std::string NoPileUpPFMEtProducer::moduleLabel_

private

Definition at line 38 of file NoPileUpPFMEtProducer.h.

Referenced by ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Modules.SwitchProducer::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and produce().

pfMEtSignInterface_

PFMEtSignInterfaceBase* NoPileUpPFMEtProducer::pfMEtSignInterface_

private

Definition at line 70 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), produce(), and ~NoPileUpPFMEtProducer().

saveInputs_

bool NoPileUpPFMEtProducer::saveInputs_

private

Definition at line 74 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfLeptonIsoCones_

double NoPileUpPFMEtProducer::sfLeptonIsoCones_

private

Definition at line 58 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfLeptonIsoConesName_

std::string NoPileUpPFMEtProducer::sfLeptonIsoConesName_

private

Definition at line 68 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfLeptonsName_

std::string NoPileUpPFMEtProducer::sfLeptonsName_

private

Definition at line 60 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfMEtCovMax_

double NoPileUpPFMEtProducer::sfMEtCovMax_

private

Definition at line 72 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfMEtCovMin_

double NoPileUpPFMEtProducer::sfMEtCovMin_

private

Definition at line 71 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUjetOffsetEnCorr_

double NoPileUpPFMEtProducer::sfNoPUjetOffsetEnCorr_

private

Definition at line 52 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUjetOffsetEnCorrName_

std::string NoPileUpPFMEtProducer::sfNoPUjetOffsetEnCorrName_

private

Definition at line 62 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUjets_

double NoPileUpPFMEtProducer::sfNoPUjets_

private

Definition at line 51 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUjetsName_

std::string NoPileUpPFMEtProducer::sfNoPUjetsName_

private

Definition at line 61 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUunclChargedCands_

double NoPileUpPFMEtProducer::sfNoPUunclChargedCands_

private

Definition at line 54 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfNoPUunclChargedCandsName_

std::string NoPileUpPFMEtProducer::sfNoPUunclChargedCandsName_

private

Definition at line 64 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfPUjets_

double NoPileUpPFMEtProducer::sfPUjets_

private

Definition at line 53 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfPUjetsName_

std::string NoPileUpPFMEtProducer::sfPUjetsName_

private

Definition at line 63 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfPUunclChargedCands_

double NoPileUpPFMEtProducer::sfPUunclChargedCands_

private

Definition at line 55 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfPUunclChargedCandsName_

std::string NoPileUpPFMEtProducer::sfPUunclChargedCandsName_

private

Definition at line 65 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfType0Correction_

double NoPileUpPFMEtProducer::sfType0Correction_

private

Definition at line 57 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfType0CorrectionName_

std::string NoPileUpPFMEtProducer::sfType0CorrectionName_

private

Definition at line 67 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfUnclNeutralCands_

double NoPileUpPFMEtProducer::sfUnclNeutralCands_

private

Definition at line 56 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

sfUnclNeutralCandsName_

std::string NoPileUpPFMEtProducer::sfUnclNeutralCandsName_

private

Definition at line 66 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcJetInfo_

edm::EDGetTokenT<reco::PUSubMETCandInfoCollection> NoPileUpPFMEtProducer::srcJetInfo_

private

Definition at line 42 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcJetInfoLeptonMatch_

edm::EDGetTokenT<reco::PUSubMETCandInfoCollection> NoPileUpPFMEtProducer::srcJetInfoLeptonMatch_

private

Definition at line 43 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcLeptons_

std::vector<edm::EDGetTokenT<reco::CandidateView> > NoPileUpPFMEtProducer::srcLeptons_

private

Definition at line 47 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcMEt_

edm::EDGetTokenT<reco::PFMETCollection> NoPileUpPFMEtProducer::srcMEt_

private

Definition at line 40 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcMEtCov_

edm::InputTag NoPileUpPFMEtProducer::srcMEtCov_

private

Definition at line 41 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcPFCandInfo_

edm::EDGetTokenT<reco::PUSubMETCandInfoCollection> NoPileUpPFMEtProducer::srcPFCandInfo_

private

Definition at line 44 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcPFCandInfoLeptonMatch_

edm::EDGetTokenT<reco::PUSubMETCandInfoCollection> NoPileUpPFMEtProducer::srcPFCandInfoLeptonMatch_

private

Definition at line 45 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

srcType0Correction_

edm::EDGetTokenT<CorrMETData> NoPileUpPFMEtProducer::srcType0Correction_

private

Definition at line 49 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer(), and produce().

utils_

NoPileUpMEtUtilities NoPileUpPFMEtProducer::utils_

private

Definition at line 78 of file NoPileUpPFMEtProducer.h.

Referenced by produce().

verbosity_

int NoPileUpPFMEtProducer::verbosity_

private

Definition at line 76 of file NoPileUpPFMEtProducer.h.

Referenced by NoPileUpPFMEtProducer().