METTester Class Reference

#include <METTester.h>

Inheritance diagram for METTester:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	METTester (const edm::ParameterSet &)
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	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
edm::EDGetTokenT< reco::CaloMETCollection >	caloMETsToken_
edm::EDGetTokenT< reco::GenMETCollection >	genMETsCaloToken_
edm::EDGetTokenT< reco::GenMETCollection >	genMETsToken_
edm::EDGetTokenT< reco::GenMETCollection >	genMETsTrueToken_
edm::InputTag	inputCaloMETLabel_
edm::InputTag	inputMETLabel_
bool	isCaloMET
bool	isGenMET
bool	isMiniAODMET
bool	isPFMET
MonitorElement *	mCaloEmEtFraction
MonitorElement *	mCaloEmEtInEB
MonitorElement *	mCaloEmEtInEE
MonitorElement *	mCaloEmEtInHF
MonitorElement *	mCaloEtFractionHadronic
MonitorElement *	mCaloHadEtInEB
MonitorElement *	mCaloHadEtInEE
MonitorElement *	mCaloHadEtInHB
MonitorElement *	mCaloHadEtInHE
MonitorElement *	mCaloHadEtInHF
MonitorElement *	mCaloHadEtInHO
MonitorElement *	mCaloMaxEtInEmTowers
MonitorElement *	mCaloMaxEtInHadTowers
MonitorElement *	mCaloSETInmHF
MonitorElement *	mCaloSETInpHF
MonitorElement *	mChargedEMEtFraction
MonitorElement *	mChargedHadEtFraction
std::map< std::string, MonitorElement * >	me
std::string	METType_
edm::InputTag	mInputCollection_
MonitorElement *	mInvisibleEtFraction
MonitorElement *	mMET
MonitorElement *	mMET_Nvtx
MonitorElement *	mMETDeltaPhi_GenMETCalo
MonitorElement *	mMETDeltaPhi_GenMETTrue
MonitorElement *	mMETDifference_GenMETCalo
MonitorElement *	mMETDifference_GenMETTrue
MonitorElement *	mMETDifference_GenMETTrue_MET0to20
MonitorElement *	mMETDifference_GenMETTrue_MET100to150
MonitorElement *	mMETDifference_GenMETTrue_MET150to200
MonitorElement *	mMETDifference_GenMETTrue_MET200to300
MonitorElement *	mMETDifference_GenMETTrue_MET20to40
MonitorElement *	mMETDifference_GenMETTrue_MET300to400
MonitorElement *	mMETDifference_GenMETTrue_MET400to500
MonitorElement *	mMETDifference_GenMETTrue_MET40to60
MonitorElement *	mMETDifference_GenMETTrue_MET500
MonitorElement *	mMETDifference_GenMETTrue_MET60to80
MonitorElement *	mMETDifference_GenMETTrue_MET80to100
MonitorElement *	mMETFine
MonitorElement *	mMETPhi
MonitorElement *	mMETSig
MonitorElement *	mMETUnc_ElectronEnDown
MonitorElement *	mMETUnc_ElectronEnUp
MonitorElement *	mMETUnc_JetEnDown
MonitorElement *	mMETUnc_JetEnUp
MonitorElement *	mMETUnc_JetResDown
MonitorElement *	mMETUnc_JetResUp
MonitorElement *	mMETUnc_MuonEnDown
MonitorElement *	mMETUnc_MuonEnUp
MonitorElement *	mMETUnc_PhotonEnDown
MonitorElement *	mMETUnc_PhotonEnUp
MonitorElement *	mMETUnc_TauEnDown
MonitorElement *	mMETUnc_TauEnUp
MonitorElement *	mMETUnc_UnclusteredEnDown
MonitorElement *	mMETUnc_UnclusteredEnUp
MonitorElement *	mMEx
MonitorElement *	mMEy
MonitorElement *	mMuonEtFraction
MonitorElement *	mNeutralEMEtFraction
MonitorElement *	mNeutralHadEtFraction
MonitorElement *	mNvertex
MonitorElement *	mPFchargedHadronEt
MonitorElement *	mPFchargedHadronEtFraction
MonitorElement *	mPFelectronEt
MonitorElement *	mPFelectronEtFraction
MonitorElement *	mPFHFEMEt
MonitorElement *	mPFHFEMEtFraction
MonitorElement *	mPFHFHadronEt
MonitorElement *	mPFHFHadronEtFraction
MonitorElement *	mPFmuonEt
MonitorElement *	mPFmuonEtFraction
MonitorElement *	mPFneutralHadronEt
MonitorElement *	mPFneutralHadronEtFraction
MonitorElement *	mPFphotonEt
MonitorElement *	mPFphotonEtFraction
MonitorElement *	mSumET
edm::EDGetTokenT< pat::METCollection >	patMETToken_
edm::EDGetTokenT< reco::PFMETCollection >	pfMETsToken_
edm::EDGetTokenT< std::vector< reco::Vertex > >	pvToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Definition at line 48 of file METTester.h.

Constructor & Destructor Documentation

METTester()

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

explicit

Definition at line 33 of file METTester.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HLT_2022v15_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                   {
  inputMETLabel_ = iConfig.getParameter<edm::InputTag>("InputMETLabel");
  METType_ = iConfig.getUntrackedParameter<std::string>("METType");

  std::string inputMETCollectionLabel(inputMETLabel_.label());

  isCaloMET = (std::string("calo") == METType_);
  isPFMET = (std::string("pf") == METType_);
  isGenMET = (std::string("gen") == METType_);
  isMiniAODMET = (std::string("miniaod") == METType_);

  pvToken_ = consumes<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("PrimaryVertices"));
  if (isCaloMET)
    caloMETsToken_ = consumes<reco::CaloMETCollection>(inputMETLabel_);
  if (isPFMET)
    pfMETsToken_ = consumes<reco::PFMETCollection>(inputMETLabel_);
  if (isMiniAODMET)
    patMETToken_ = consumes<pat::METCollection>(inputMETLabel_);
  if (isGenMET)
    genMETsToken_ = consumes<reco::GenMETCollection>(inputMETLabel_);
  if (!isMiniAODMET) {
    genMETsTrueToken_ = consumes<reco::GenMETCollection>(edm::InputTag("genMetTrue"));
    genMETsCaloToken_ = consumes<reco::GenMETCollection>(edm::InputTag("genMetCalo"));
  }

  // Events variables
  mNvertex = nullptr;

  // Common variables
  mMEx = nullptr;
  mMEy = nullptr;
  mMETSig = nullptr;
  mMET = nullptr;
  mMETFine = nullptr;
  mMET_Nvtx = nullptr;
  mMETPhi = nullptr;
  mSumET = nullptr;
  mMETDifference_GenMETTrue = nullptr;
  mMETDeltaPhi_GenMETTrue = nullptr;
  mMETDifference_GenMETCalo = nullptr;
  mMETDeltaPhi_GenMETCalo = nullptr;

  // MET Uncertainities: Only for MiniAOD
  mMETUnc_JetResUp = nullptr;
  mMETUnc_JetResDown = nullptr;
  mMETUnc_JetEnUp = nullptr;
  mMETUnc_JetEnDown = nullptr;
  mMETUnc_MuonEnUp = nullptr;
  mMETUnc_MuonEnDown = nullptr;
  mMETUnc_ElectronEnUp = nullptr;
  mMETUnc_ElectronEnDown = nullptr;
  mMETUnc_TauEnUp = nullptr;
  mMETUnc_TauEnDown = nullptr;
  mMETUnc_UnclusteredEnUp = nullptr;
  mMETUnc_UnclusteredEnDown = nullptr;
  mMETUnc_PhotonEnUp = nullptr;
  mMETUnc_PhotonEnDown = nullptr;

  // CaloMET variables
  mCaloMaxEtInEmTowers = nullptr;
  mCaloMaxEtInHadTowers = nullptr;
  mCaloEtFractionHadronic = nullptr;
  mCaloEmEtFraction = nullptr;
  mCaloHadEtInHB = nullptr;
  mCaloHadEtInHO = nullptr;
  mCaloHadEtInHE = nullptr;
  mCaloHadEtInHF = nullptr;
  mCaloEmEtInHF = nullptr;
  mCaloSETInpHF = nullptr;
  mCaloSETInmHF = nullptr;
  mCaloEmEtInEE = nullptr;
  mCaloEmEtInEB = nullptr;

  // GenMET variables
  mNeutralEMEtFraction = nullptr;
  mNeutralHadEtFraction = nullptr;
  mChargedEMEtFraction = nullptr;
  mChargedHadEtFraction = nullptr;
  mMuonEtFraction = nullptr;
  mInvisibleEtFraction = nullptr;

  // MET variables

  // PFMET variables
  mMETDifference_GenMETTrue_MET0to20 = nullptr;
  mMETDifference_GenMETTrue_MET20to40 = nullptr;
  mMETDifference_GenMETTrue_MET40to60 = nullptr;
  mMETDifference_GenMETTrue_MET60to80 = nullptr;
  mMETDifference_GenMETTrue_MET80to100 = nullptr;
  mMETDifference_GenMETTrue_MET100to150 = nullptr;
  mMETDifference_GenMETTrue_MET150to200 = nullptr;
  mMETDifference_GenMETTrue_MET200to300 = nullptr;
  mMETDifference_GenMETTrue_MET300to400 = nullptr;
  mMETDifference_GenMETTrue_MET400to500 = nullptr;
  mMETDifference_GenMETTrue_MET500 = nullptr;
}

Member Function Documentation

analyze()

void METTester::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 234 of file METTester.cc.

References cms::cuda::assert(), reco::CaloMET::CaloSETInmHF(), reco::CaloMET::CaloSETInpHF(), pat::MET::ChargedEMEtFraction(), pat::MET::ChargedHadEtFraction(), reco::PFMET::chargedHadronEt(), reco::PFMET::chargedHadronEtFraction(), gather_cfg::cout, pat::MET::ElectronEnDown, pat::MET::ElectronEnUp, reco::PFMET::electronEt(), reco::PFMET::electronEtFraction(), reco::CaloMET::emEtFraction(), reco::CaloMET::emEtInEB(), reco::CaloMET::emEtInEE(), reco::CaloMET::emEtInHF(), reco::CaloMET::etFractionHadronic(), RazorAnalyzer::genmet, genMetCalo_cfi::genMetCalo, genMetTrue_cfi::genMetTrue, reco::CaloMET::hadEtInHB(), reco::CaloMET::hadEtInHE(), reco::CaloMET::hadEtInHF(), reco::CaloMET::hadEtInHO(), reco::PFMET::HFEMEt(), reco::PFMET::HFEMEtFraction(), reco::PFMET::HFHadronEt(), reco::PFMET::HFHadronEtFraction(), iEvent, pat::MET::isPFMET(), edm::HandleBase::isValid(), pat::MET::JetEnDown, pat::MET::JetEnUp, pat::MET::JetResDown, pat::MET::JetResUp, reco::CaloMET::maxEtInEmTowers(), reco::CaloMET::maxEtInHadTowers(), BTaggingMonitor_cfi::met, pat::MET::MuonEnDown, pat::MET::MuonEnUp, reco::PFMET::muonEt(), reco::PFMET::muonEtFraction(), pat::MET::MuonEtFraction(), pat::MET::NeutralEMFraction(), pat::MET::NeutralHadEtFraction(), reco::PFMET::neutralHadronEt(), reco::PFMET::neutralHadronEtFraction(), pat::MET::PhotonEnDown, pat::MET::PhotonEnUp, reco::PFMET::photonEt(), reco::PFMET::photonEtFraction(), edm::Handle< T >::product(), pat::MET::shiftedPt(), pat::MET::TauEnDown, pat::MET::TauEnUp, pat::MET::Type6EtFraction(), pat::MET::Type7EtFraction(), pat::MET::UnclusteredEnDown, and pat::MET::UnclusteredEnUp.

                                                     {  // int counter(0);

  edm::Handle<reco::VertexCollection> pvHandle;
  iEvent.getByToken(pvToken_, pvHandle);
  if (!pvHandle.isValid()) {
    std::cout << __FUNCTION__ << ":" << __LINE__ << ":pvHandle handle not found!" << std::endl;
    assert(false);
  }
  const int nvtx = pvHandle->size();
  mNvertex->Fill(nvtx);
  // Collections for all MET collections

  edm::Handle<CaloMETCollection> caloMETs;
  edm::Handle<PFMETCollection> pfMETs;
  edm::Handle<GenMETCollection> genMETs;
  edm::Handle<pat::METCollection> patMET;

  if (isCaloMET)
    iEvent.getByToken(caloMETsToken_, caloMETs);
  if (isPFMET)
    iEvent.getByToken(pfMETsToken_, pfMETs);
  if (isGenMET)
    iEvent.getByToken(genMETsToken_, genMETs);
  if (isMiniAODMET)
    iEvent.getByToken(patMETToken_, patMET);
  if ((isCaloMET) and !caloMETs.isValid())
    return;
  if ((isPFMET) and !pfMETs.isValid())
    return;
  if ((isGenMET) and !genMETs.isValid())
    return;
  if ((isMiniAODMET) and !patMET.isValid())
    return;

  reco::MET met;
  if (isCaloMET) {
    met = caloMETs->front();
  }
  if (isPFMET) {
    met = pfMETs->front();
  }
  if (isGenMET) {
    met = genMETs->front();
  }
  if (isMiniAODMET) {
    met = patMET->front();
  }

  const double SumET = met.sumEt();
  const double METSig = met.mEtSig();
  const double MET = met.pt();
  const double MEx = met.px();
  const double MEy = met.py();
  const double METPhi = met.phi();
  mMEx->Fill(MEx);
  mMEy->Fill(MEy);
  mMET->Fill(MET);
  mMETFine->Fill(MET);
  mMET_Nvtx->Fill((double)nvtx, MET);
  mMETPhi->Fill(METPhi);
  mSumET->Fill(SumET);
  mMETSig->Fill(METSig);

  // Get Generated MET for Resolution plots
  const reco::GenMET *genMetTrue = nullptr;
  bool isvalidgenmet = false;

  if (!isMiniAODMET) {
    edm::Handle<GenMETCollection> genTrue;
    iEvent.getByToken(genMETsTrueToken_, genTrue);
    if (genTrue.isValid()) {
      isvalidgenmet = true;
      const GenMETCollection *genmetcol = genTrue.product();
      genMetTrue = &(genmetcol->front());
    }
  } else {
    genMetTrue = patMET->front().genMET();
    isvalidgenmet = true;
  }

  if (isvalidgenmet) {
    double genMET = genMetTrue->pt();
    double genMETPhi = genMetTrue->phi();

    mMETDifference_GenMETTrue->Fill(MET - genMET);
    mMETDeltaPhi_GenMETTrue->Fill(TMath::ACos(TMath::Cos(METPhi - genMETPhi)));

    if (!isGenMET) {
      // pfMET resolution in pfMET bins : Sam, Feb, 2012
      if (MET > 0 && MET < 20)
        mMETDifference_GenMETTrue_MET0to20->Fill(MET - genMET);
      else if (MET > 20 && MET < 40)
        mMETDifference_GenMETTrue_MET20to40->Fill(MET - genMET);
      else if (MET > 40 && MET < 60)
        mMETDifference_GenMETTrue_MET40to60->Fill(MET - genMET);
      else if (MET > 60 && MET < 80)
        mMETDifference_GenMETTrue_MET60to80->Fill(MET - genMET);
      else if (MET > 80 && MET < 100)
        mMETDifference_GenMETTrue_MET80to100->Fill(MET - genMET);
      else if (MET > 100 && MET < 150)
        mMETDifference_GenMETTrue_MET100to150->Fill(MET - genMET);
      else if (MET > 150 && MET < 200)
        mMETDifference_GenMETTrue_MET150to200->Fill(MET - genMET);
      else if (MET > 200 && MET < 300)
        mMETDifference_GenMETTrue_MET200to300->Fill(MET - genMET);
      else if (MET > 300 && MET < 400)
        mMETDifference_GenMETTrue_MET300to400->Fill(MET - genMET);
      else if (MET > 400 && MET < 500)
        mMETDifference_GenMETTrue_MET400to500->Fill(MET - genMET);
      else if (MET > 500)
        mMETDifference_GenMETTrue_MET500->Fill(MET - genMET);

    } else {
      edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetTrue";
    }
  }
  if (!isMiniAODMET) {
    edm::Handle<GenMETCollection> genCalo;
    iEvent.getByToken(genMETsCaloToken_, genCalo);
    if (genCalo.isValid()) {
      const GenMETCollection *genmetcol = genCalo.product();
      const GenMET *genMetCalo = &(genmetcol->front());
      const double genMET = genMetCalo->pt();
      const double genMETPhi = genMetCalo->phi();

      mMETDifference_GenMETCalo->Fill(MET - genMET);
      mMETDeltaPhi_GenMETCalo->Fill(TMath::ACos(TMath::Cos(METPhi - genMETPhi)));
    } else {
      edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task:  genMetCalo";
    }
  }
  if (isCaloMET) {
    const reco::CaloMET *calomet = &(caloMETs->front());
    // ==========================================================
    // Reconstructed MET Information
    const double caloMaxEtInEMTowers = calomet->maxEtInEmTowers();
    const double caloMaxEtInHadTowers = calomet->maxEtInHadTowers();
    const double caloEtFractionHadronic = calomet->etFractionHadronic();
    const double caloEmEtFraction = calomet->emEtFraction();
    const double caloHadEtInHB = calomet->hadEtInHB();
    const double caloHadEtInHO = calomet->hadEtInHO();
    const double caloHadEtInHE = calomet->hadEtInHE();
    const double caloHadEtInHF = calomet->hadEtInHF();
    const double caloEmEtInEB = calomet->emEtInEB();
    const double caloEmEtInEE = calomet->emEtInEE();
    const double caloEmEtInHF = calomet->emEtInHF();
    const double caloSETInpHF = calomet->CaloSETInpHF();
    const double caloSETInmHF = calomet->CaloSETInmHF();

    mCaloMaxEtInEmTowers->Fill(caloMaxEtInEMTowers);
    mCaloMaxEtInHadTowers->Fill(caloMaxEtInHadTowers);
    mCaloEtFractionHadronic->Fill(caloEtFractionHadronic);
    mCaloEmEtFraction->Fill(caloEmEtFraction);
    mCaloHadEtInHB->Fill(caloHadEtInHB);
    mCaloHadEtInHO->Fill(caloHadEtInHO);
    mCaloHadEtInHE->Fill(caloHadEtInHE);
    mCaloHadEtInHF->Fill(caloHadEtInHF);
    mCaloEmEtInEB->Fill(caloEmEtInEB);
    mCaloEmEtInEE->Fill(caloEmEtInEE);
    mCaloEmEtInHF->Fill(caloEmEtInHF);
    mCaloSETInpHF->Fill(caloSETInpHF);
    mCaloSETInmHF->Fill(caloSETInmHF);
  }
  if (isGenMET) {
    const GenMET *genmet;
    // Get Generated MET
    genmet = &(genMETs->front());

    const double NeutralEMEtFraction = genmet->NeutralEMEtFraction();
    const double NeutralHadEtFraction = genmet->NeutralHadEtFraction();
    const double ChargedEMEtFraction = genmet->ChargedEMEtFraction();
    const double ChargedHadEtFraction = genmet->ChargedHadEtFraction();
    const double MuonEtFraction = genmet->MuonEtFraction();
    const double InvisibleEtFraction = genmet->InvisibleEtFraction();

    mNeutralEMEtFraction->Fill(NeutralEMEtFraction);
    mNeutralHadEtFraction->Fill(NeutralHadEtFraction);
    mChargedEMEtFraction->Fill(ChargedEMEtFraction);
    mChargedHadEtFraction->Fill(ChargedHadEtFraction);
    mMuonEtFraction->Fill(MuonEtFraction);
    mInvisibleEtFraction->Fill(InvisibleEtFraction);
  }
  if (isPFMET) {
    const reco::PFMET *pfmet = &(pfMETs->front());
    mPFphotonEtFraction->Fill(pfmet->photonEtFraction());
    mPFphotonEt->Fill(pfmet->photonEt());
    mPFneutralHadronEtFraction->Fill(pfmet->neutralHadronEtFraction());
    mPFneutralHadronEt->Fill(pfmet->neutralHadronEt());
    mPFelectronEtFraction->Fill(pfmet->electronEtFraction());
    mPFelectronEt->Fill(pfmet->electronEt());
    mPFchargedHadronEtFraction->Fill(pfmet->chargedHadronEtFraction());
    mPFchargedHadronEt->Fill(pfmet->chargedHadronEt());
    mPFmuonEtFraction->Fill(pfmet->muonEtFraction());
    mPFmuonEt->Fill(pfmet->muonEt());
    mPFHFHadronEtFraction->Fill(pfmet->HFHadronEtFraction());
    mPFHFHadronEt->Fill(pfmet->HFHadronEt());
    mPFHFEMEtFraction->Fill(pfmet->HFEMEtFraction());
    mPFHFEMEt->Fill(pfmet->HFEMEt());
    // Reconstructed MET Information
  }
  if (isMiniAODMET) {
    const pat::MET *patmet = &(patMET->front());
    mMETUnc_JetResUp->Fill(MET - patmet->shiftedPt(pat::MET::JetResUp));
    mMETUnc_JetResDown->Fill(MET - patmet->shiftedPt(pat::MET::JetResDown));
    mMETUnc_JetEnUp->Fill(MET - patmet->shiftedPt(pat::MET::JetEnUp));
    mMETUnc_JetEnDown->Fill(MET - patmet->shiftedPt(pat::MET::JetEnDown));
    mMETUnc_MuonEnUp->Fill(MET - patmet->shiftedPt(pat::MET::MuonEnUp));
    mMETUnc_MuonEnDown->Fill(MET - patmet->shiftedPt(pat::MET::MuonEnDown));
    mMETUnc_ElectronEnUp->Fill(MET - patmet->shiftedPt(pat::MET::ElectronEnUp));
    mMETUnc_ElectronEnDown->Fill(MET - patmet->shiftedPt(pat::MET::ElectronEnDown));
    mMETUnc_TauEnUp->Fill(MET - patmet->shiftedPt(pat::MET::TauEnUp));
    mMETUnc_TauEnDown->Fill(MET - patmet->shiftedPt(pat::MET::TauEnDown));
    mMETUnc_UnclusteredEnUp->Fill(MET - patmet->shiftedPt(pat::MET::UnclusteredEnUp));
    mMETUnc_UnclusteredEnDown->Fill(MET - patmet->shiftedPt(pat::MET::UnclusteredEnDown));
    mMETUnc_PhotonEnUp->Fill(MET - patmet->shiftedPt(pat::MET::PhotonEnUp));
    mMETUnc_PhotonEnDown->Fill(MET - patmet->shiftedPt(pat::MET::PhotonEnDown));

    if (patmet->isPFMET()) {
      mPFphotonEtFraction->Fill(patmet->NeutralEMFraction());
      mPFneutralHadronEtFraction->Fill(patmet->NeutralHadEtFraction());
      mPFelectronEtFraction->Fill(patmet->ChargedEMEtFraction());
      mPFchargedHadronEtFraction->Fill(patmet->ChargedHadEtFraction());
      mPFmuonEtFraction->Fill(patmet->MuonEtFraction());
      mPFHFHadronEtFraction->Fill(patmet->Type6EtFraction());  // HFHadrons
      mPFHFEMEtFraction->Fill(patmet->Type7EtFraction());      // HFEMEt
    }
  }
}

bookHistograms()

void METTester::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 129 of file METTester.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::bookProfile(), and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                                                    {
  ibooker.setCurrentFolder("JetMET/METValidation/" + inputMETLabel_.label());

  mNvertex = ibooker.book1D("Nvertex", "Nvertex", 80, 0, 80);
  mMEx = ibooker.book1D("MEx", "MEx", 160, -800, 800);
  mMEy = ibooker.book1D("MEy", "MEy", 160, -800, 800);
  mMETSig = ibooker.book1D("METSig", "METSig", 25, 0, 24.5);
  mMET = ibooker.book1D("MET", "MET (20 GeV binning)", 100, 0, 2000);
  mMETFine = ibooker.book1D("METFine", "MET (2 GeV binning)", 1000, 0, 2000);
  mMET_Nvtx = ibooker.bookProfile("MET_Nvtx", "MET vs. nvtx", 60, 0., 60., 0., 2000., " ");
  mMETPhi = ibooker.book1D("METPhi", "METPhi", 80, -4, 4);
  mSumET = ibooker.book1D("SumET", "SumET", 200, 0, 4000);  // 10GeV
  mMETDifference_GenMETTrue = ibooker.book1D("METDifference_GenMETTrue", "METDifference_GenMETTrue", 500, -500, 500);
  mMETDeltaPhi_GenMETTrue = ibooker.book1D("METDeltaPhi_GenMETTrue", "METDeltaPhi_GenMETTrue", 80, 0, 4);

  if (isMiniAODMET) {
    mMETUnc_JetResUp = ibooker.book1D("METUnc_JetResUp", "METUnc_JetResUp", 200, -10, 10);
    mMETUnc_JetResDown = ibooker.book1D("METUnc_JetResDown", "METUnc_JetResDown", 200, -10, 10);
    mMETUnc_JetEnUp = ibooker.book1D("METUnc_JetEnUp", "METUnc_JetEnUp", 200, -10, 10);
    mMETUnc_JetEnDown = ibooker.book1D("METUnc_JetEnDown", "METUnc_JetEnDown", 200, -10, 10);
    mMETUnc_MuonEnUp = ibooker.book1D("METUnc_MuonEnUp", "METUnc_MuonEnUp", 200, -10, 10);
    mMETUnc_MuonEnDown = ibooker.book1D("METUnc_MuonEnDown", "METUnc_MuonEnDown", 200, -10, 10);
    mMETUnc_ElectronEnUp = ibooker.book1D("METUnc_ElectronEnUp", "METUnc_ElectronEnUp", 200, -10, 10);
    mMETUnc_ElectronEnDown = ibooker.book1D("METUnc_ElectronEnDown", "METUnc_ElectronEnDown", 200, -10, 10);
    mMETUnc_TauEnUp = ibooker.book1D("METUnc_TauEnUp", "METUnc_TauEnUp", 200, -10, 10);
    mMETUnc_TauEnDown = ibooker.book1D("METUnc_TauEnDown", "METUnc_TauEnDown", 200, -10, 10);
    mMETUnc_UnclusteredEnUp = ibooker.book1D("METUnc_UnclusteredEnUp", "METUnc_UnclusteredEnUp", 200, -10, 10);
    mMETUnc_UnclusteredEnDown = ibooker.book1D("METUnc_UnclusteredEnDown", "METUnc_UnclusteredEnDown", 200, -10, 10);
    mMETUnc_PhotonEnUp = ibooker.book1D("METUnc_UnclusteredEnDown", "METUnc_UnclusteredEnDown", 200, -10, 10);
    mMETUnc_PhotonEnDown = ibooker.book1D("METUnc_PhotonEnDown", "METUnc_PhotonEnDown", 200, -10, 10);
  }
  if (!isMiniAODMET) {
    mMETDifference_GenMETCalo = ibooker.book1D("METDifference_GenMETCalo", "METDifference_GenMETCalo", 500, -500, 500);
    mMETDeltaPhi_GenMETCalo = ibooker.book1D("METDeltaPhi_GenMETCalo", "METDeltaPhi_GenMETCalo", 80, 0, 4);
  }
  if (!isGenMET) {
    mMETDifference_GenMETTrue_MET0to20 =
        ibooker.book1D("METResolution_GenMETTrue_MET0to20", "METResolution_GenMETTrue_MET0to20", 500, -500, 500);
    mMETDifference_GenMETTrue_MET20to40 =
        ibooker.book1D("METResolution_GenMETTrue_MET20to40", "METResolution_GenMETTrue_MET20to40", 500, -500, 500);
    mMETDifference_GenMETTrue_MET40to60 =
        ibooker.book1D("METResolution_GenMETTrue_MET40to60", "METResolution_GenMETTrue_MET40to60", 500, -500, 500);
    mMETDifference_GenMETTrue_MET60to80 =
        ibooker.book1D("METResolution_GenMETTrue_MET60to80", "METResolution_GenMETTrue_MET60to80", 500, -500, 500);
    mMETDifference_GenMETTrue_MET80to100 =
        ibooker.book1D("METResolution_GenMETTrue_MET80to100", "METResolution_GenMETTrue_MET80to100", 500, -500, 500);
    mMETDifference_GenMETTrue_MET100to150 =
        ibooker.book1D("METResolution_GenMETTrue_MET100to150", "METResolution_GenMETTrue_MET100to150", 500, -500, 500);
    mMETDifference_GenMETTrue_MET150to200 =
        ibooker.book1D("METResolution_GenMETTrue_MET150to200", "METResolution_GenMETTrue_MET150to200", 500, -500, 500);
    mMETDifference_GenMETTrue_MET200to300 =
        ibooker.book1D("METResolution_GenMETTrue_MET200to300", "METResolution_GenMETTrue_MET200to300", 500, -500, 500);
    mMETDifference_GenMETTrue_MET300to400 =
        ibooker.book1D("METResolution_GenMETTrue_MET300to400", "METResolution_GenMETTrue_MET300to400", 500, -500, 500);
    mMETDifference_GenMETTrue_MET400to500 =
        ibooker.book1D("METResolution_GenMETTrue_MET400to500", "METResolution_GenMETTrue_MET400to500", 500, -500, 500);
    mMETDifference_GenMETTrue_MET500 =
        ibooker.book1D("METResolution_GenMETTrue_MET500", "METResolution_GenMETTrue_MET500", 500, -500, 500);
  }
  if (isCaloMET) {
    mCaloMaxEtInEmTowers = ibooker.book1D("CaloMaxEtInEmTowers", "CaloMaxEtInEmTowers", 300, 0, 1500);     // 5GeV
    mCaloMaxEtInHadTowers = ibooker.book1D("CaloMaxEtInHadTowers", "CaloMaxEtInHadTowers", 300, 0, 1500);  // 5GeV
    mCaloEtFractionHadronic = ibooker.book1D("CaloEtFractionHadronic", "CaloEtFractionHadronic", 100, 0, 1);
    mCaloEmEtFraction = ibooker.book1D("CaloEmEtFraction", "CaloEmEtFraction", 100, 0, 1);
    mCaloHadEtInHB = ibooker.book1D("CaloHadEtInHB", "CaloHadEtInHB", 200, 0, 2000);  // 5GeV
    mCaloHadEtInHE = ibooker.book1D("CaloHadEtInHE", "CaloHadEtInHE", 100, 0, 500);   // 5GeV
    mCaloHadEtInHO = ibooker.book1D("CaloHadEtInHO", "CaloHadEtInHO", 100, 0, 200);   // 5GeV
    mCaloHadEtInHF = ibooker.book1D("CaloHadEtInHF", "CaloHadEtInHF", 100, 0, 200);   // 5GeV
    mCaloSETInpHF = ibooker.book1D("CaloSETInpHF", "CaloSETInpHF", 100, 0, 500);
    mCaloSETInmHF = ibooker.book1D("CaloSETInmHF", "CaloSETInmHF", 100, 0, 500);
    mCaloEmEtInEE = ibooker.book1D("CaloEmEtInEE", "CaloEmEtInEE", 100, 0, 500);  // 5GeV
    mCaloEmEtInEB = ibooker.book1D("CaloEmEtInEB", "CaloEmEtInEB", 100, 0, 500);  // 5GeV
    mCaloEmEtInHF = ibooker.book1D("CaloEmEtInHF", "CaloEmEtInHF", 100, 0, 500);  // 5GeV
  }

  if (isGenMET) {
    mNeutralEMEtFraction = ibooker.book1D("GenNeutralEMEtFraction", "GenNeutralEMEtFraction", 120, 0.0, 1.2);
    mNeutralHadEtFraction = ibooker.book1D("GenNeutralHadEtFraction", "GenNeutralHadEtFraction", 120, 0.0, 1.2);
    mChargedEMEtFraction = ibooker.book1D("GenChargedEMEtFraction", "GenChargedEMEtFraction", 120, 0.0, 1.2);
    mChargedHadEtFraction = ibooker.book1D("GenChargedHadEtFraction", "GenChargedHadEtFraction", 120, 0.0, 1.2);
    mMuonEtFraction = ibooker.book1D("GenMuonEtFraction", "GenMuonEtFraction", 120, 0.0, 1.2);
    mInvisibleEtFraction = ibooker.book1D("GenInvisibleEtFraction", "GenInvisibleEtFraction", 120, 0.0, 1.2);
  }

  if (isPFMET || isMiniAODMET) {
    mPFphotonEtFraction = ibooker.book1D("photonEtFraction", "photonEtFraction", 100, 0, 1);
    mPFneutralHadronEtFraction = ibooker.book1D("neutralHadronEtFraction", "neutralHadronEtFraction", 100, 0, 1);
    mPFelectronEtFraction = ibooker.book1D("electronEtFraction", "electronEtFraction", 100, 0, 1);
    mPFchargedHadronEtFraction = ibooker.book1D("chargedHadronEtFraction", "chargedHadronEtFraction", 100, 0, 1);
    mPFHFHadronEtFraction = ibooker.book1D("HFHadronEtFraction", "HFHadronEtFraction", 100, 0, 1);
    mPFmuonEtFraction = ibooker.book1D("muonEtFraction", "muonEtFraction", 100, 0, 1);
    mPFHFEMEtFraction = ibooker.book1D("HFEMEtFraction", "HFEMEtFraction", 100, 0, 1);

    if (!isMiniAODMET) {
      mPFphotonEt = ibooker.book1D("photonEt", "photonEt", 100, 0, 1000);
      mPFneutralHadronEt = ibooker.book1D("neutralHadronEt", "neutralHadronEt", 100, 0, 1000);
      mPFelectronEt = ibooker.book1D("electronEt", "electronEt", 100, 0, 1000);
      mPFchargedHadronEt = ibooker.book1D("chargedHadronEt", "chargedHadronEt", 100, 0, 1000);
      mPFmuonEt = ibooker.book1D("muonEt", "muonEt", 100, 0, 1000);
      mPFHFHadronEt = ibooker.book1D("HFHadronEt", "HFHadronEt", 100, 0, 500);
      mPFHFEMEt = ibooker.book1D("HFEMEt", "HFEMEt", 100, 0, 300);
    }
  }
}

Member Data Documentation

caloMETsToken_

edm::EDGetTokenT<reco::CaloMETCollection> METTester::caloMETsToken_

private

Definition at line 68 of file METTester.h.

genMETsCaloToken_

edm::EDGetTokenT<reco::GenMETCollection> METTester::genMETsCaloToken_

private

Definition at line 73 of file METTester.h.

genMETsToken_

edm::EDGetTokenT<reco::GenMETCollection> METTester::genMETsToken_

private

Definition at line 71 of file METTester.h.

genMETsTrueToken_

edm::EDGetTokenT<reco::GenMETCollection> METTester::genMETsTrueToken_

private

Definition at line 72 of file METTester.h.

inputCaloMETLabel_

edm::InputTag METTester::inputCaloMETLabel_

private

Definition at line 64 of file METTester.h.

inputMETLabel_

edm::InputTag METTester::inputMETLabel_

private

Definition at line 61 of file METTester.h.

isCaloMET

bool METTester::isCaloMET

private

Definition at line 167 of file METTester.h.

isGenMET

bool METTester::isGenMET

private

Definition at line 171 of file METTester.h.

isMiniAODMET

bool METTester::isMiniAODMET

private

Definition at line 172 of file METTester.h.

isPFMET

bool METTester::isPFMET

private

Definition at line 170 of file METTester.h.

mCaloEmEtFraction

MonitorElement* METTester::mCaloEmEtFraction

private

Definition at line 114 of file METTester.h.

mCaloEmEtInEB

MonitorElement* METTester::mCaloEmEtInEB

private

Definition at line 125 of file METTester.h.

mCaloEmEtInEE

MonitorElement* METTester::mCaloEmEtInEE

private

Definition at line 124 of file METTester.h.

mCaloEmEtInHF

MonitorElement* METTester::mCaloEmEtInHF

private

Definition at line 121 of file METTester.h.

mCaloEtFractionHadronic

MonitorElement* METTester::mCaloEtFractionHadronic

private

Definition at line 113 of file METTester.h.

mCaloHadEtInEB

MonitorElement* METTester::mCaloHadEtInEB

private

Definition at line 119 of file METTester.h.

mCaloHadEtInEE

MonitorElement* METTester::mCaloHadEtInEE

private

Definition at line 120 of file METTester.h.

mCaloHadEtInHB

MonitorElement* METTester::mCaloHadEtInHB

private

Definition at line 115 of file METTester.h.

mCaloHadEtInHE

MonitorElement* METTester::mCaloHadEtInHE

private

Definition at line 117 of file METTester.h.

mCaloHadEtInHF

MonitorElement* METTester::mCaloHadEtInHF

private

Definition at line 118 of file METTester.h.

mCaloHadEtInHO

MonitorElement* METTester::mCaloHadEtInHO

private

Definition at line 116 of file METTester.h.

mCaloMaxEtInEmTowers

MonitorElement* METTester::mCaloMaxEtInEmTowers

private

Definition at line 111 of file METTester.h.

mCaloMaxEtInHadTowers

MonitorElement* METTester::mCaloMaxEtInHadTowers

private

Definition at line 112 of file METTester.h.

mCaloSETInmHF

MonitorElement* METTester::mCaloSETInmHF

private

Definition at line 123 of file METTester.h.

mCaloSETInpHF

MonitorElement* METTester::mCaloSETInpHF

private

Definition at line 122 of file METTester.h.

mChargedEMEtFraction

MonitorElement* METTester::mChargedEMEtFraction

private

Definition at line 130 of file METTester.h.

mChargedHadEtFraction

MonitorElement* METTester::mChargedHadEtFraction

private

Definition at line 131 of file METTester.h.

me

std::map<std::string, MonitorElement *> METTester::me

private

Definition at line 56 of file METTester.h.

METType_

std::string METTester::METType_

private

Definition at line 62 of file METTester.h.

mInputCollection_

edm::InputTag METTester::mInputCollection_

private

Definition at line 60 of file METTester.h.

mInvisibleEtFraction

MonitorElement* METTester::mInvisibleEtFraction

private

Definition at line 133 of file METTester.h.

mMET

MonitorElement* METTester::mMET

private

Definition at line 83 of file METTester.h.

mMET_Nvtx

MonitorElement* METTester::mMET_Nvtx

private

Definition at line 85 of file METTester.h.

mMETDeltaPhi_GenMETCalo

MonitorElement* METTester::mMETDeltaPhi_GenMETCalo

private

Definition at line 91 of file METTester.h.

mMETDeltaPhi_GenMETTrue

MonitorElement* METTester::mMETDeltaPhi_GenMETTrue

private

Definition at line 89 of file METTester.h.

mMETDifference_GenMETCalo

MonitorElement* METTester::mMETDifference_GenMETCalo

private

Definition at line 90 of file METTester.h.

mMETDifference_GenMETTrue

MonitorElement* METTester::mMETDifference_GenMETTrue

private

Definition at line 88 of file METTester.h.

mMETDifference_GenMETTrue_MET0to20

MonitorElement* METTester::mMETDifference_GenMETTrue_MET0to20

private

Definition at line 153 of file METTester.h.

mMETDifference_GenMETTrue_MET100to150

MonitorElement* METTester::mMETDifference_GenMETTrue_MET100to150

private

Definition at line 158 of file METTester.h.

mMETDifference_GenMETTrue_MET150to200

MonitorElement* METTester::mMETDifference_GenMETTrue_MET150to200

private

Definition at line 159 of file METTester.h.

mMETDifference_GenMETTrue_MET200to300

MonitorElement* METTester::mMETDifference_GenMETTrue_MET200to300

private

Definition at line 160 of file METTester.h.

mMETDifference_GenMETTrue_MET20to40

MonitorElement* METTester::mMETDifference_GenMETTrue_MET20to40

private

Definition at line 154 of file METTester.h.

mMETDifference_GenMETTrue_MET300to400

MonitorElement* METTester::mMETDifference_GenMETTrue_MET300to400

private

Definition at line 161 of file METTester.h.

mMETDifference_GenMETTrue_MET400to500

MonitorElement* METTester::mMETDifference_GenMETTrue_MET400to500

private

Definition at line 162 of file METTester.h.

mMETDifference_GenMETTrue_MET40to60

MonitorElement* METTester::mMETDifference_GenMETTrue_MET40to60

private

Definition at line 155 of file METTester.h.

mMETDifference_GenMETTrue_MET500

MonitorElement* METTester::mMETDifference_GenMETTrue_MET500

private

Definition at line 163 of file METTester.h.

mMETDifference_GenMETTrue_MET60to80

MonitorElement* METTester::mMETDifference_GenMETTrue_MET60to80

private

Definition at line 156 of file METTester.h.

mMETDifference_GenMETTrue_MET80to100

MonitorElement* METTester::mMETDifference_GenMETTrue_MET80to100

private

Definition at line 157 of file METTester.h.

mMETFine

MonitorElement* METTester::mMETFine

private

Definition at line 84 of file METTester.h.

mMETPhi

MonitorElement* METTester::mMETPhi

private

Definition at line 86 of file METTester.h.

mMETSig

MonitorElement* METTester::mMETSig

private

Definition at line 82 of file METTester.h.

mMETUnc_ElectronEnDown

MonitorElement* METTester::mMETUnc_ElectronEnDown

private

Definition at line 101 of file METTester.h.

mMETUnc_ElectronEnUp

MonitorElement* METTester::mMETUnc_ElectronEnUp

private

Definition at line 100 of file METTester.h.

mMETUnc_JetEnDown

MonitorElement* METTester::mMETUnc_JetEnDown

private

Definition at line 97 of file METTester.h.

mMETUnc_JetEnUp

MonitorElement* METTester::mMETUnc_JetEnUp

private

Definition at line 96 of file METTester.h.

mMETUnc_JetResDown

MonitorElement* METTester::mMETUnc_JetResDown

private

Definition at line 95 of file METTester.h.

mMETUnc_JetResUp

MonitorElement* METTester::mMETUnc_JetResUp

private

Definition at line 94 of file METTester.h.

mMETUnc_MuonEnDown

MonitorElement* METTester::mMETUnc_MuonEnDown

private

Definition at line 99 of file METTester.h.

mMETUnc_MuonEnUp

MonitorElement* METTester::mMETUnc_MuonEnUp

private

Definition at line 98 of file METTester.h.

mMETUnc_PhotonEnDown

MonitorElement* METTester::mMETUnc_PhotonEnDown

private

Definition at line 107 of file METTester.h.

mMETUnc_PhotonEnUp

MonitorElement* METTester::mMETUnc_PhotonEnUp

private

Definition at line 106 of file METTester.h.

mMETUnc_TauEnDown

MonitorElement* METTester::mMETUnc_TauEnDown

private

Definition at line 103 of file METTester.h.

mMETUnc_TauEnUp

MonitorElement* METTester::mMETUnc_TauEnUp

private

Definition at line 102 of file METTester.h.

mMETUnc_UnclusteredEnDown

MonitorElement* METTester::mMETUnc_UnclusteredEnDown

private

Definition at line 105 of file METTester.h.

mMETUnc_UnclusteredEnUp

MonitorElement* METTester::mMETUnc_UnclusteredEnUp

private

Definition at line 104 of file METTester.h.

mMEx

MonitorElement* METTester::mMEx

private

Definition at line 80 of file METTester.h.

mMEy

MonitorElement* METTester::mMEy

private

Definition at line 81 of file METTester.h.

mMuonEtFraction

MonitorElement* METTester::mMuonEtFraction

private

Definition at line 132 of file METTester.h.

mNeutralEMEtFraction

MonitorElement* METTester::mNeutralEMEtFraction

private

Definition at line 128 of file METTester.h.

mNeutralHadEtFraction

MonitorElement* METTester::mNeutralHadEtFraction

private

Definition at line 129 of file METTester.h.

mNvertex

MonitorElement* METTester::mNvertex

private

Definition at line 77 of file METTester.h.

mPFchargedHadronEt

MonitorElement* METTester::mPFchargedHadronEt

private

Definition at line 145 of file METTester.h.

mPFchargedHadronEtFraction

MonitorElement* METTester::mPFchargedHadronEtFraction

private

Definition at line 144 of file METTester.h.

mPFelectronEt

MonitorElement* METTester::mPFelectronEt

private

Definition at line 143 of file METTester.h.

mPFelectronEtFraction

MonitorElement* METTester::mPFelectronEtFraction

private

Definition at line 142 of file METTester.h.

mPFHFEMEt

MonitorElement* METTester::mPFHFEMEt

private

Definition at line 151 of file METTester.h.

mPFHFEMEtFraction

MonitorElement* METTester::mPFHFEMEtFraction

private

Definition at line 150 of file METTester.h.

mPFHFHadronEt

MonitorElement* METTester::mPFHFHadronEt

private

Definition at line 149 of file METTester.h.

mPFHFHadronEtFraction

MonitorElement* METTester::mPFHFHadronEtFraction

private

Definition at line 148 of file METTester.h.

mPFmuonEt

MonitorElement* METTester::mPFmuonEt

private

Definition at line 147 of file METTester.h.

mPFmuonEtFraction

MonitorElement* METTester::mPFmuonEtFraction

private

Definition at line 146 of file METTester.h.

mPFneutralHadronEt

MonitorElement* METTester::mPFneutralHadronEt

private

Definition at line 141 of file METTester.h.

mPFneutralHadronEtFraction

MonitorElement* METTester::mPFneutralHadronEtFraction

private

Definition at line 140 of file METTester.h.

mPFphotonEt

MonitorElement* METTester::mPFphotonEt

private

Definition at line 139 of file METTester.h.

mPFphotonEtFraction

MonitorElement* METTester::mPFphotonEtFraction

private

Definition at line 138 of file METTester.h.

mSumET

MonitorElement* METTester::mSumET

private

Definition at line 87 of file METTester.h.

patMETToken_

edm::EDGetTokenT<pat::METCollection> METTester::patMETToken_

private

Definition at line 74 of file METTester.h.

pfMETsToken_

edm::EDGetTokenT<reco::PFMETCollection> METTester::pfMETsToken_

private

Definition at line 69 of file METTester.h.

pvToken_

edm::EDGetTokenT<std::vector<reco::Vertex> > METTester::pvToken_

private

Definition at line 67 of file METTester.h.