CMS 3D CMS Logo
List of all members | Public Member Functions | Private Attributes
METTester Class Reference

#include <METTester.h>

Inheritance diagram for METTester:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

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 50 of file METTester.h.

Constructor & Destructor Documentation

◆ METTester()

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

Definition at line 33 of file METTester.cc.

33  {
34  inputMETLabel_ = iConfig.getParameter<edm::InputTag>("InputMETLabel");
35  METType_ = iConfig.getUntrackedParameter<std::string>("METType");
36 
37  std::string inputMETCollectionLabel(inputMETLabel_.label());
38 
39  isCaloMET = (std::string("calo") == METType_);
40  isPFMET = (std::string("pf") == METType_);
41  isGenMET = (std::string("gen") == METType_);
42  isMiniAODMET = (std::string("miniaod") == METType_);
43 
44  pvToken_ = consumes<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("PrimaryVertices"));
45  if (isCaloMET)
46  caloMETsToken_ = consumes<reco::CaloMETCollection>(inputMETLabel_);
47  if (isPFMET)
48  pfMETsToken_ = consumes<reco::PFMETCollection>(inputMETLabel_);
49  if (isMiniAODMET)
50  patMETToken_ = consumes<pat::METCollection>(inputMETLabel_);
51  if (isGenMET)
52  genMETsToken_ = consumes<reco::GenMETCollection>(inputMETLabel_);
53  if (!isMiniAODMET) {
54  genMETsTrueToken_ = consumes<reco::GenMETCollection>(edm::InputTag("genMetTrue"));
55  genMETsCaloToken_ = consumes<reco::GenMETCollection>(edm::InputTag("genMetCalo"));
56  }
57 
58  // Events variables
59  mNvertex = nullptr;
60 
61  // Common variables
62  mMEx = nullptr;
63  mMEy = nullptr;
64  mMETSig = nullptr;
65  mMET = nullptr;
66  mMETFine = nullptr;
67  mMET_Nvtx = nullptr;
68  mMETPhi = nullptr;
69  mSumET = nullptr;
70  mMETDifference_GenMETTrue = nullptr;
71  mMETDeltaPhi_GenMETTrue = nullptr;
72  mMETDifference_GenMETCalo = nullptr;
73  mMETDeltaPhi_GenMETCalo = nullptr;
74 
75  // MET Uncertainities: Only for MiniAOD
76  mMETUnc_JetResUp = nullptr;
77  mMETUnc_JetResDown = nullptr;
78  mMETUnc_JetEnUp = nullptr;
79  mMETUnc_JetEnDown = nullptr;
80  mMETUnc_MuonEnUp = nullptr;
81  mMETUnc_MuonEnDown = nullptr;
82  mMETUnc_ElectronEnUp = nullptr;
83  mMETUnc_ElectronEnDown = nullptr;
84  mMETUnc_TauEnUp = nullptr;
85  mMETUnc_TauEnDown = nullptr;
86  mMETUnc_UnclusteredEnUp = nullptr;
87  mMETUnc_UnclusteredEnDown = nullptr;
88  mMETUnc_PhotonEnUp = nullptr;
89  mMETUnc_PhotonEnDown = nullptr;
90 
91  // CaloMET variables
92  mCaloMaxEtInEmTowers = nullptr;
93  mCaloMaxEtInHadTowers = nullptr;
94  mCaloEtFractionHadronic = nullptr;
95  mCaloEmEtFraction = nullptr;
96  mCaloHadEtInHB = nullptr;
97  mCaloHadEtInHO = nullptr;
98  mCaloHadEtInHE = nullptr;
99  mCaloHadEtInHF = nullptr;
100  mCaloEmEtInHF = nullptr;
101  mCaloSETInpHF = nullptr;
102  mCaloSETInmHF = nullptr;
103  mCaloEmEtInEE = nullptr;
104  mCaloEmEtInEB = nullptr;
105 
106  // GenMET variables
107  mNeutralEMEtFraction = nullptr;
108  mNeutralHadEtFraction = nullptr;
109  mChargedEMEtFraction = nullptr;
110  mChargedHadEtFraction = nullptr;
111  mMuonEtFraction = nullptr;
112  mInvisibleEtFraction = nullptr;
113 
114  // MET variables
115 
116  // PFMET variables
117  mMETDifference_GenMETTrue_MET0to20 = nullptr;
118  mMETDifference_GenMETTrue_MET20to40 = nullptr;
119  mMETDifference_GenMETTrue_MET40to60 = nullptr;
120  mMETDifference_GenMETTrue_MET60to80 = nullptr;
121  mMETDifference_GenMETTrue_MET80to100 = nullptr;
122  mMETDifference_GenMETTrue_MET100to150 = nullptr;
123  mMETDifference_GenMETTrue_MET150to200 = nullptr;
124  mMETDifference_GenMETTrue_MET200to300 = nullptr;
125  mMETDifference_GenMETTrue_MET300to400 = nullptr;
126  mMETDifference_GenMETTrue_MET400to500 = nullptr;
127  mMETDifference_GenMETTrue_MET500 = nullptr;
128 }

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

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.

235  { // int counter(0);
236 
237  edm::Handle<reco::VertexCollection> pvHandle;
238  iEvent.getByToken(pvToken_, pvHandle);
239  if (!pvHandle.isValid()) {
240  std::cout << __FUNCTION__ << ":" << __LINE__ << ":pvHandle handle not found!" << std::endl;
241  assert(false);
242  }
243  const int nvtx = pvHandle->size();
244  mNvertex->Fill(nvtx);
245  // Collections for all MET collections
246 
247  edm::Handle<CaloMETCollection> caloMETs;
248  edm::Handle<PFMETCollection> pfMETs;
249  edm::Handle<GenMETCollection> genMETs;
250  edm::Handle<pat::METCollection> patMET;
251 
252  if (isCaloMET)
253  iEvent.getByToken(caloMETsToken_, caloMETs);
254  if (isPFMET)
255  iEvent.getByToken(pfMETsToken_, pfMETs);
256  if (isGenMET)
257  iEvent.getByToken(genMETsToken_, genMETs);
258  if (isMiniAODMET)
259  iEvent.getByToken(patMETToken_, patMET);
260  if ((isCaloMET) and !caloMETs.isValid())
261  return;
262  if ((isPFMET) and !pfMETs.isValid())
263  return;
264  if ((isGenMET) and !genMETs.isValid())
265  return;
266  if ((isMiniAODMET) and !patMET.isValid())
267  return;
268 
269  reco::MET met;
270  if (isCaloMET) {
271  met = caloMETs->front();
272  }
273  if (isPFMET) {
274  met = pfMETs->front();
275  }
276  if (isGenMET) {
277  met = genMETs->front();
278  }
279  if (isMiniAODMET) {
280  met = patMET->front();
281  }
282 
283  const double SumET = met.sumEt();
284  const double METSig = met.mEtSig();
285  const double MET = met.pt();
286  const double MEx = met.px();
287  const double MEy = met.py();
288  const double METPhi = met.phi();
289  mMEx->Fill(MEx);
290  mMEy->Fill(MEy);
291  mMET->Fill(MET);
292  mMETFine->Fill(MET);
293  mMET_Nvtx->Fill((double)nvtx, MET);
294  mMETPhi->Fill(METPhi);
295  mSumET->Fill(SumET);
296  mMETSig->Fill(METSig);
297 
298  // Get Generated MET for Resolution plots
299  const reco::GenMET *genMetTrue = nullptr;
300  bool isvalidgenmet = false;
301 
302  if (!isMiniAODMET) {
303  edm::Handle<GenMETCollection> genTrue;
304  iEvent.getByToken(genMETsTrueToken_, genTrue);
305  if (genTrue.isValid()) {
306  isvalidgenmet = true;
307  const GenMETCollection *genmetcol = genTrue.product();
308  genMetTrue = &(genmetcol->front());
309  }
310  } else {
311  genMetTrue = patMET->front().genMET();
312  isvalidgenmet = true;
313  }
314 
315  if (isvalidgenmet) {
316  double genMET = genMetTrue->pt();
317  double genMETPhi = genMetTrue->phi();
318 
319  mMETDifference_GenMETTrue->Fill(MET - genMET);
320  mMETDeltaPhi_GenMETTrue->Fill(TMath::ACos(TMath::Cos(METPhi - genMETPhi)));
321 
322  if (!isGenMET) {
323  // pfMET resolution in pfMET bins : Sam, Feb, 2012
324  if (MET > 0 && MET < 20)
325  mMETDifference_GenMETTrue_MET0to20->Fill(MET - genMET);
326  else if (MET > 20 && MET < 40)
327  mMETDifference_GenMETTrue_MET20to40->Fill(MET - genMET);
328  else if (MET > 40 && MET < 60)
329  mMETDifference_GenMETTrue_MET40to60->Fill(MET - genMET);
330  else if (MET > 60 && MET < 80)
331  mMETDifference_GenMETTrue_MET60to80->Fill(MET - genMET);
332  else if (MET > 80 && MET < 100)
333  mMETDifference_GenMETTrue_MET80to100->Fill(MET - genMET);
334  else if (MET > 100 && MET < 150)
335  mMETDifference_GenMETTrue_MET100to150->Fill(MET - genMET);
336  else if (MET > 150 && MET < 200)
337  mMETDifference_GenMETTrue_MET150to200->Fill(MET - genMET);
338  else if (MET > 200 && MET < 300)
339  mMETDifference_GenMETTrue_MET200to300->Fill(MET - genMET);
340  else if (MET > 300 && MET < 400)
341  mMETDifference_GenMETTrue_MET300to400->Fill(MET - genMET);
342  else if (MET > 400 && MET < 500)
343  mMETDifference_GenMETTrue_MET400to500->Fill(MET - genMET);
344  else if (MET > 500)
345  mMETDifference_GenMETTrue_MET500->Fill(MET - genMET);
346 
347  } else {
348  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
349  }
350  }
351  if (!isMiniAODMET) {
352  edm::Handle<GenMETCollection> genCalo;
353  iEvent.getByToken(genMETsCaloToken_, genCalo);
354  if (genCalo.isValid()) {
355  const GenMETCollection *genmetcol = genCalo.product();
356  const GenMET *genMetCalo = &(genmetcol->front());
357  const double genMET = genMetCalo->pt();
358  const double genMETPhi = genMetCalo->phi();
359 
360  mMETDifference_GenMETCalo->Fill(MET - genMET);
361  mMETDeltaPhi_GenMETCalo->Fill(TMath::ACos(TMath::Cos(METPhi - genMETPhi)));
362  } else {
363  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
364  }
365  }
366  if (isCaloMET) {
367  const reco::CaloMET *calomet = &(caloMETs->front());
368  // ==========================================================
369  // Reconstructed MET Information
370  const double caloMaxEtInEMTowers = calomet->maxEtInEmTowers();
371  const double caloMaxEtInHadTowers = calomet->maxEtInHadTowers();
372  const double caloEtFractionHadronic = calomet->etFractionHadronic();
373  const double caloEmEtFraction = calomet->emEtFraction();
374  const double caloHadEtInHB = calomet->hadEtInHB();
375  const double caloHadEtInHO = calomet->hadEtInHO();
376  const double caloHadEtInHE = calomet->hadEtInHE();
377  const double caloHadEtInHF = calomet->hadEtInHF();
378  const double caloEmEtInEB = calomet->emEtInEB();
379  const double caloEmEtInEE = calomet->emEtInEE();
380  const double caloEmEtInHF = calomet->emEtInHF();
381  const double caloSETInpHF = calomet->CaloSETInpHF();
382  const double caloSETInmHF = calomet->CaloSETInmHF();
383 
384  mCaloMaxEtInEmTowers->Fill(caloMaxEtInEMTowers);
385  mCaloMaxEtInHadTowers->Fill(caloMaxEtInHadTowers);
386  mCaloEtFractionHadronic->Fill(caloEtFractionHadronic);
387  mCaloEmEtFraction->Fill(caloEmEtFraction);
388  mCaloHadEtInHB->Fill(caloHadEtInHB);
389  mCaloHadEtInHO->Fill(caloHadEtInHO);
390  mCaloHadEtInHE->Fill(caloHadEtInHE);
391  mCaloHadEtInHF->Fill(caloHadEtInHF);
392  mCaloEmEtInEB->Fill(caloEmEtInEB);
393  mCaloEmEtInEE->Fill(caloEmEtInEE);
394  mCaloEmEtInHF->Fill(caloEmEtInHF);
395  mCaloSETInpHF->Fill(caloSETInpHF);
396  mCaloSETInmHF->Fill(caloSETInmHF);
397  }
398  if (isGenMET) {
399  const GenMET *genmet;
400  // Get Generated MET
401  genmet = &(genMETs->front());
402 
403  const double NeutralEMEtFraction = genmet->NeutralEMEtFraction();
404  const double NeutralHadEtFraction = genmet->NeutralHadEtFraction();
405  const double ChargedEMEtFraction = genmet->ChargedEMEtFraction();
406  const double ChargedHadEtFraction = genmet->ChargedHadEtFraction();
407  const double MuonEtFraction = genmet->MuonEtFraction();
408  const double InvisibleEtFraction = genmet->InvisibleEtFraction();
409 
410  mNeutralEMEtFraction->Fill(NeutralEMEtFraction);
411  mNeutralHadEtFraction->Fill(NeutralHadEtFraction);
412  mChargedEMEtFraction->Fill(ChargedEMEtFraction);
413  mChargedHadEtFraction->Fill(ChargedHadEtFraction);
414  mMuonEtFraction->Fill(MuonEtFraction);
415  mInvisibleEtFraction->Fill(InvisibleEtFraction);
416  }
417  if (isPFMET) {
418  const reco::PFMET *pfmet = &(pfMETs->front());
419  mPFphotonEtFraction->Fill(pfmet->photonEtFraction());
420  mPFphotonEt->Fill(pfmet->photonEt());
421  mPFneutralHadronEtFraction->Fill(pfmet->neutralHadronEtFraction());
422  mPFneutralHadronEt->Fill(pfmet->neutralHadronEt());
423  mPFelectronEtFraction->Fill(pfmet->electronEtFraction());
424  mPFelectronEt->Fill(pfmet->electronEt());
425  mPFchargedHadronEtFraction->Fill(pfmet->chargedHadronEtFraction());
426  mPFchargedHadronEt->Fill(pfmet->chargedHadronEt());
427  mPFmuonEtFraction->Fill(pfmet->muonEtFraction());
428  mPFmuonEt->Fill(pfmet->muonEt());
429  mPFHFHadronEtFraction->Fill(pfmet->HFHadronEtFraction());
430  mPFHFHadronEt->Fill(pfmet->HFHadronEt());
431  mPFHFEMEtFraction->Fill(pfmet->HFEMEtFraction());
432  mPFHFEMEt->Fill(pfmet->HFEMEt());
433  // Reconstructed MET Information
434  }
435  if (isMiniAODMET) {
436  const pat::MET *patmet = &(patMET->front());
437  mMETUnc_JetResUp->Fill(MET - patmet->shiftedPt(pat::MET::JetResUp));
438  mMETUnc_JetResDown->Fill(MET - patmet->shiftedPt(pat::MET::JetResDown));
439  mMETUnc_JetEnUp->Fill(MET - patmet->shiftedPt(pat::MET::JetEnUp));
440  mMETUnc_JetEnDown->Fill(MET - patmet->shiftedPt(pat::MET::JetEnDown));
441  mMETUnc_MuonEnUp->Fill(MET - patmet->shiftedPt(pat::MET::MuonEnUp));
442  mMETUnc_MuonEnDown->Fill(MET - patmet->shiftedPt(pat::MET::MuonEnDown));
443  mMETUnc_ElectronEnUp->Fill(MET - patmet->shiftedPt(pat::MET::ElectronEnUp));
444  mMETUnc_ElectronEnDown->Fill(MET - patmet->shiftedPt(pat::MET::ElectronEnDown));
445  mMETUnc_TauEnUp->Fill(MET - patmet->shiftedPt(pat::MET::TauEnUp));
446  mMETUnc_TauEnDown->Fill(MET - patmet->shiftedPt(pat::MET::TauEnDown));
447  mMETUnc_UnclusteredEnUp->Fill(MET - patmet->shiftedPt(pat::MET::UnclusteredEnUp));
448  mMETUnc_UnclusteredEnDown->Fill(MET - patmet->shiftedPt(pat::MET::UnclusteredEnDown));
449  mMETUnc_PhotonEnUp->Fill(MET - patmet->shiftedPt(pat::MET::PhotonEnUp));
450  mMETUnc_PhotonEnDown->Fill(MET - patmet->shiftedPt(pat::MET::PhotonEnDown));
451 
452  if (patmet->isPFMET()) {
453  mPFphotonEtFraction->Fill(patmet->NeutralEMFraction());
454  mPFneutralHadronEtFraction->Fill(patmet->NeutralHadEtFraction());
455  mPFelectronEtFraction->Fill(patmet->ChargedEMEtFraction());
456  mPFchargedHadronEtFraction->Fill(patmet->ChargedHadEtFraction());
457  mPFmuonEtFraction->Fill(patmet->MuonEtFraction());
458  mPFHFHadronEtFraction->Fill(patmet->Type6EtFraction()); // HFHadrons
459  mPFHFEMEtFraction->Fill(patmet->Type7EtFraction()); // HFEMEt
460  }
461  }
462 }

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.

◆ 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.

129  {
130  ibooker.setCurrentFolder("JetMET/METValidation/" + inputMETLabel_.label());
131 
132  mNvertex = ibooker.book1D("Nvertex", "Nvertex", 80, 0, 80);
133  mMEx = ibooker.book1D("MEx", "MEx", 160, -800, 800);
134  mMEy = ibooker.book1D("MEy", "MEy", 160, -800, 800);
135  mMETSig = ibooker.book1D("METSig", "METSig", 25, 0, 24.5);
136  mMET = ibooker.book1D("MET", "MET (20 GeV binning)", 100, 0, 2000);
137  mMETFine = ibooker.book1D("METFine", "MET (2 GeV binning)", 1000, 0, 2000);
138  mMET_Nvtx = ibooker.bookProfile("MET_Nvtx", "MET vs. nvtx", 60, 0., 60., 0., 2000., " ");
139  mMETPhi = ibooker.book1D("METPhi", "METPhi", 80, -4, 4);
140  mSumET = ibooker.book1D("SumET", "SumET", 200, 0, 4000); // 10GeV
141  mMETDifference_GenMETTrue = ibooker.book1D("METDifference_GenMETTrue", "METDifference_GenMETTrue", 500, -500, 500);
142  mMETDeltaPhi_GenMETTrue = ibooker.book1D("METDeltaPhi_GenMETTrue", "METDeltaPhi_GenMETTrue", 80, 0, 4);
143 
144  if (isMiniAODMET) {
145  mMETUnc_JetResUp = ibooker.book1D("METUnc_JetResUp", "METUnc_JetResUp", 200, -10, 10);
146  mMETUnc_JetResDown = ibooker.book1D("METUnc_JetResDown", "METUnc_JetResDown", 200, -10, 10);
147  mMETUnc_JetEnUp = ibooker.book1D("METUnc_JetEnUp", "METUnc_JetEnUp", 200, -10, 10);
148  mMETUnc_JetEnDown = ibooker.book1D("METUnc_JetEnDown", "METUnc_JetEnDown", 200, -10, 10);
149  mMETUnc_MuonEnUp = ibooker.book1D("METUnc_MuonEnUp", "METUnc_MuonEnUp", 200, -10, 10);
150  mMETUnc_MuonEnDown = ibooker.book1D("METUnc_MuonEnDown", "METUnc_MuonEnDown", 200, -10, 10);
151  mMETUnc_ElectronEnUp = ibooker.book1D("METUnc_ElectronEnUp", "METUnc_ElectronEnUp", 200, -10, 10);
152  mMETUnc_ElectronEnDown = ibooker.book1D("METUnc_ElectronEnDown", "METUnc_ElectronEnDown", 200, -10, 10);
153  mMETUnc_TauEnUp = ibooker.book1D("METUnc_TauEnUp", "METUnc_TauEnUp", 200, -10, 10);
154  mMETUnc_TauEnDown = ibooker.book1D("METUnc_TauEnDown", "METUnc_TauEnDown", 200, -10, 10);
155  mMETUnc_UnclusteredEnUp = ibooker.book1D("METUnc_UnclusteredEnUp", "METUnc_UnclusteredEnUp", 200, -10, 10);
156  mMETUnc_UnclusteredEnDown = ibooker.book1D("METUnc_UnclusteredEnDown", "METUnc_UnclusteredEnDown", 200, -10, 10);
157  mMETUnc_PhotonEnUp = ibooker.book1D("METUnc_UnclusteredEnDown", "METUnc_UnclusteredEnDown", 200, -10, 10);
158  mMETUnc_PhotonEnDown = ibooker.book1D("METUnc_PhotonEnDown", "METUnc_PhotonEnDown", 200, -10, 10);
159  }
160  if (!isMiniAODMET) {
161  mMETDifference_GenMETCalo = ibooker.book1D("METDifference_GenMETCalo", "METDifference_GenMETCalo", 500, -500, 500);
162  mMETDeltaPhi_GenMETCalo = ibooker.book1D("METDeltaPhi_GenMETCalo", "METDeltaPhi_GenMETCalo", 80, 0, 4);
163  }
164  if (!isGenMET) {
165  mMETDifference_GenMETTrue_MET0to20 =
166  ibooker.book1D("METResolution_GenMETTrue_MET0to20", "METResolution_GenMETTrue_MET0to20", 500, -500, 500);
167  mMETDifference_GenMETTrue_MET20to40 =
168  ibooker.book1D("METResolution_GenMETTrue_MET20to40", "METResolution_GenMETTrue_MET20to40", 500, -500, 500);
169  mMETDifference_GenMETTrue_MET40to60 =
170  ibooker.book1D("METResolution_GenMETTrue_MET40to60", "METResolution_GenMETTrue_MET40to60", 500, -500, 500);
171  mMETDifference_GenMETTrue_MET60to80 =
172  ibooker.book1D("METResolution_GenMETTrue_MET60to80", "METResolution_GenMETTrue_MET60to80", 500, -500, 500);
173  mMETDifference_GenMETTrue_MET80to100 =
174  ibooker.book1D("METResolution_GenMETTrue_MET80to100", "METResolution_GenMETTrue_MET80to100", 500, -500, 500);
175  mMETDifference_GenMETTrue_MET100to150 =
176  ibooker.book1D("METResolution_GenMETTrue_MET100to150", "METResolution_GenMETTrue_MET100to150", 500, -500, 500);
177  mMETDifference_GenMETTrue_MET150to200 =
178  ibooker.book1D("METResolution_GenMETTrue_MET150to200", "METResolution_GenMETTrue_MET150to200", 500, -500, 500);
179  mMETDifference_GenMETTrue_MET200to300 =
180  ibooker.book1D("METResolution_GenMETTrue_MET200to300", "METResolution_GenMETTrue_MET200to300", 500, -500, 500);
181  mMETDifference_GenMETTrue_MET300to400 =
182  ibooker.book1D("METResolution_GenMETTrue_MET300to400", "METResolution_GenMETTrue_MET300to400", 500, -500, 500);
183  mMETDifference_GenMETTrue_MET400to500 =
184  ibooker.book1D("METResolution_GenMETTrue_MET400to500", "METResolution_GenMETTrue_MET400to500", 500, -500, 500);
185  mMETDifference_GenMETTrue_MET500 =
186  ibooker.book1D("METResolution_GenMETTrue_MET500", "METResolution_GenMETTrue_MET500", 500, -500, 500);
187  }
188  if (isCaloMET) {
189  mCaloMaxEtInEmTowers = ibooker.book1D("CaloMaxEtInEmTowers", "CaloMaxEtInEmTowers", 300, 0, 1500); // 5GeV
190  mCaloMaxEtInHadTowers = ibooker.book1D("CaloMaxEtInHadTowers", "CaloMaxEtInHadTowers", 300, 0, 1500); // 5GeV
191  mCaloEtFractionHadronic = ibooker.book1D("CaloEtFractionHadronic", "CaloEtFractionHadronic", 100, 0, 1);
192  mCaloEmEtFraction = ibooker.book1D("CaloEmEtFraction", "CaloEmEtFraction", 100, 0, 1);
193  mCaloHadEtInHB = ibooker.book1D("CaloHadEtInHB", "CaloHadEtInHB", 200, 0, 2000); // 5GeV
194  mCaloHadEtInHE = ibooker.book1D("CaloHadEtInHE", "CaloHadEtInHE", 100, 0, 500); // 5GeV
195  mCaloHadEtInHO = ibooker.book1D("CaloHadEtInHO", "CaloHadEtInHO", 100, 0, 200); // 5GeV
196  mCaloHadEtInHF = ibooker.book1D("CaloHadEtInHF", "CaloHadEtInHF", 100, 0, 200); // 5GeV
197  mCaloSETInpHF = ibooker.book1D("CaloSETInpHF", "CaloSETInpHF", 100, 0, 500);
198  mCaloSETInmHF = ibooker.book1D("CaloSETInmHF", "CaloSETInmHF", 100, 0, 500);
199  mCaloEmEtInEE = ibooker.book1D("CaloEmEtInEE", "CaloEmEtInEE", 100, 0, 500); // 5GeV
200  mCaloEmEtInEB = ibooker.book1D("CaloEmEtInEB", "CaloEmEtInEB", 100, 0, 500); // 5GeV
201  mCaloEmEtInHF = ibooker.book1D("CaloEmEtInHF", "CaloEmEtInHF", 100, 0, 500); // 5GeV
202  }
203 
204  if (isGenMET) {
205  mNeutralEMEtFraction = ibooker.book1D("GenNeutralEMEtFraction", "GenNeutralEMEtFraction", 120, 0.0, 1.2);
206  mNeutralHadEtFraction = ibooker.book1D("GenNeutralHadEtFraction", "GenNeutralHadEtFraction", 120, 0.0, 1.2);
207  mChargedEMEtFraction = ibooker.book1D("GenChargedEMEtFraction", "GenChargedEMEtFraction", 120, 0.0, 1.2);
208  mChargedHadEtFraction = ibooker.book1D("GenChargedHadEtFraction", "GenChargedHadEtFraction", 120, 0.0, 1.2);
209  mMuonEtFraction = ibooker.book1D("GenMuonEtFraction", "GenMuonEtFraction", 120, 0.0, 1.2);
210  mInvisibleEtFraction = ibooker.book1D("GenInvisibleEtFraction", "GenInvisibleEtFraction", 120, 0.0, 1.2);
211  }
212 
213  if (isPFMET || isMiniAODMET) {
214  mPFphotonEtFraction = ibooker.book1D("photonEtFraction", "photonEtFraction", 100, 0, 1);
215  mPFneutralHadronEtFraction = ibooker.book1D("neutralHadronEtFraction", "neutralHadronEtFraction", 100, 0, 1);
216  mPFelectronEtFraction = ibooker.book1D("electronEtFraction", "electronEtFraction", 100, 0, 1);
217  mPFchargedHadronEtFraction = ibooker.book1D("chargedHadronEtFraction", "chargedHadronEtFraction", 100, 0, 1);
218  mPFHFHadronEtFraction = ibooker.book1D("HFHadronEtFraction", "HFHadronEtFraction", 100, 0, 1);
219  mPFmuonEtFraction = ibooker.book1D("muonEtFraction", "muonEtFraction", 100, 0, 1);
220  mPFHFEMEtFraction = ibooker.book1D("HFEMEtFraction", "HFEMEtFraction", 100, 0, 1);
221 
222  if (!isMiniAODMET) {
223  mPFphotonEt = ibooker.book1D("photonEt", "photonEt", 100, 0, 1000);
224  mPFneutralHadronEt = ibooker.book1D("neutralHadronEt", "neutralHadronEt", 100, 0, 1000);
225  mPFelectronEt = ibooker.book1D("electronEt", "electronEt", 100, 0, 1000);
226  mPFchargedHadronEt = ibooker.book1D("chargedHadronEt", "chargedHadronEt", 100, 0, 1000);
227  mPFmuonEt = ibooker.book1D("muonEt", "muonEt", 100, 0, 1000);
228  mPFHFHadronEt = ibooker.book1D("HFHadronEt", "HFHadronEt", 100, 0, 500);
229  mPFHFEMEt = ibooker.book1D("HFEMEt", "HFEMEt", 100, 0, 300);
230  }
231  }
232 }

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

Member Data Documentation

◆ caloMETsToken_

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

Definition at line 70 of file METTester.h.

◆ genMETsCaloToken_

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

Definition at line 75 of file METTester.h.

◆ genMETsToken_

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

Definition at line 73 of file METTester.h.

◆ genMETsTrueToken_

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

Definition at line 74 of file METTester.h.

◆ inputCaloMETLabel_

edm::InputTag METTester::inputCaloMETLabel_
private

Definition at line 66 of file METTester.h.

◆ inputMETLabel_

edm::InputTag METTester::inputMETLabel_
private

Definition at line 63 of file METTester.h.

◆ isCaloMET

bool METTester::isCaloMET
private

Definition at line 169 of file METTester.h.

◆ isGenMET

bool METTester::isGenMET
private

Definition at line 173 of file METTester.h.

◆ isMiniAODMET

bool METTester::isMiniAODMET
private

Definition at line 174 of file METTester.h.

◆ isPFMET

bool METTester::isPFMET
private

Definition at line 172 of file METTester.h.

◆ mCaloEmEtFraction

MonitorElement* METTester::mCaloEmEtFraction
private

Definition at line 116 of file METTester.h.

◆ mCaloEmEtInEB

MonitorElement* METTester::mCaloEmEtInEB
private

Definition at line 127 of file METTester.h.

◆ mCaloEmEtInEE

MonitorElement* METTester::mCaloEmEtInEE
private

Definition at line 126 of file METTester.h.

◆ mCaloEmEtInHF

MonitorElement* METTester::mCaloEmEtInHF
private

Definition at line 123 of file METTester.h.

◆ mCaloEtFractionHadronic

MonitorElement* METTester::mCaloEtFractionHadronic
private

Definition at line 115 of file METTester.h.

◆ mCaloHadEtInEB

MonitorElement* METTester::mCaloHadEtInEB
private

Definition at line 121 of file METTester.h.

◆ mCaloHadEtInEE

MonitorElement* METTester::mCaloHadEtInEE
private

Definition at line 122 of file METTester.h.

◆ mCaloHadEtInHB

MonitorElement* METTester::mCaloHadEtInHB
private

Definition at line 117 of file METTester.h.

◆ mCaloHadEtInHE

MonitorElement* METTester::mCaloHadEtInHE
private

Definition at line 119 of file METTester.h.

◆ mCaloHadEtInHF

MonitorElement* METTester::mCaloHadEtInHF
private

Definition at line 120 of file METTester.h.

◆ mCaloHadEtInHO

MonitorElement* METTester::mCaloHadEtInHO
private

Definition at line 118 of file METTester.h.

◆ mCaloMaxEtInEmTowers

MonitorElement* METTester::mCaloMaxEtInEmTowers
private

Definition at line 113 of file METTester.h.

◆ mCaloMaxEtInHadTowers

MonitorElement* METTester::mCaloMaxEtInHadTowers
private

Definition at line 114 of file METTester.h.

◆ mCaloSETInmHF

MonitorElement* METTester::mCaloSETInmHF
private

Definition at line 125 of file METTester.h.

◆ mCaloSETInpHF

MonitorElement* METTester::mCaloSETInpHF
private

Definition at line 124 of file METTester.h.

◆ mChargedEMEtFraction

MonitorElement* METTester::mChargedEMEtFraction
private

Definition at line 132 of file METTester.h.

◆ mChargedHadEtFraction

MonitorElement* METTester::mChargedHadEtFraction
private

Definition at line 133 of file METTester.h.

◆ me

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

Definition at line 58 of file METTester.h.

◆ METType_

std::string METTester::METType_
private

Definition at line 64 of file METTester.h.

◆ mInputCollection_

edm::InputTag METTester::mInputCollection_
private

Definition at line 62 of file METTester.h.

◆ mInvisibleEtFraction

MonitorElement* METTester::mInvisibleEtFraction
private

Definition at line 135 of file METTester.h.

◆ mMET

MonitorElement* METTester::mMET
private

Definition at line 85 of file METTester.h.

◆ mMET_Nvtx

MonitorElement* METTester::mMET_Nvtx
private

Definition at line 87 of file METTester.h.

◆ mMETDeltaPhi_GenMETCalo

MonitorElement* METTester::mMETDeltaPhi_GenMETCalo
private

Definition at line 93 of file METTester.h.

◆ mMETDeltaPhi_GenMETTrue

MonitorElement* METTester::mMETDeltaPhi_GenMETTrue
private

Definition at line 91 of file METTester.h.

◆ mMETDifference_GenMETCalo

MonitorElement* METTester::mMETDifference_GenMETCalo
private

Definition at line 92 of file METTester.h.

◆ mMETDifference_GenMETTrue

MonitorElement* METTester::mMETDifference_GenMETTrue
private

Definition at line 90 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET0to20

MonitorElement* METTester::mMETDifference_GenMETTrue_MET0to20
private

Definition at line 155 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET100to150

MonitorElement* METTester::mMETDifference_GenMETTrue_MET100to150
private

Definition at line 160 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET150to200

MonitorElement* METTester::mMETDifference_GenMETTrue_MET150to200
private

Definition at line 161 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET200to300

MonitorElement* METTester::mMETDifference_GenMETTrue_MET200to300
private

Definition at line 162 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET20to40

MonitorElement* METTester::mMETDifference_GenMETTrue_MET20to40
private

Definition at line 156 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET300to400

MonitorElement* METTester::mMETDifference_GenMETTrue_MET300to400
private

Definition at line 163 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET400to500

MonitorElement* METTester::mMETDifference_GenMETTrue_MET400to500
private

Definition at line 164 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET40to60

MonitorElement* METTester::mMETDifference_GenMETTrue_MET40to60
private

Definition at line 157 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET500

MonitorElement* METTester::mMETDifference_GenMETTrue_MET500
private

Definition at line 165 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET60to80

MonitorElement* METTester::mMETDifference_GenMETTrue_MET60to80
private

Definition at line 158 of file METTester.h.

◆ mMETDifference_GenMETTrue_MET80to100

MonitorElement* METTester::mMETDifference_GenMETTrue_MET80to100
private

Definition at line 159 of file METTester.h.

◆ mMETFine

MonitorElement* METTester::mMETFine
private

Definition at line 86 of file METTester.h.

◆ mMETPhi

MonitorElement* METTester::mMETPhi
private

Definition at line 88 of file METTester.h.

◆ mMETSig

MonitorElement* METTester::mMETSig
private

Definition at line 84 of file METTester.h.

◆ mMETUnc_ElectronEnDown

MonitorElement* METTester::mMETUnc_ElectronEnDown
private

Definition at line 103 of file METTester.h.

◆ mMETUnc_ElectronEnUp

MonitorElement* METTester::mMETUnc_ElectronEnUp
private

Definition at line 102 of file METTester.h.

◆ mMETUnc_JetEnDown

MonitorElement* METTester::mMETUnc_JetEnDown
private

Definition at line 99 of file METTester.h.

◆ mMETUnc_JetEnUp

MonitorElement* METTester::mMETUnc_JetEnUp
private

Definition at line 98 of file METTester.h.

◆ mMETUnc_JetResDown

MonitorElement* METTester::mMETUnc_JetResDown
private

Definition at line 97 of file METTester.h.

◆ mMETUnc_JetResUp

MonitorElement* METTester::mMETUnc_JetResUp
private

Definition at line 96 of file METTester.h.

◆ mMETUnc_MuonEnDown

MonitorElement* METTester::mMETUnc_MuonEnDown
private

Definition at line 101 of file METTester.h.

◆ mMETUnc_MuonEnUp

MonitorElement* METTester::mMETUnc_MuonEnUp
private

Definition at line 100 of file METTester.h.

◆ mMETUnc_PhotonEnDown

MonitorElement* METTester::mMETUnc_PhotonEnDown
private

Definition at line 109 of file METTester.h.

◆ mMETUnc_PhotonEnUp

MonitorElement* METTester::mMETUnc_PhotonEnUp
private

Definition at line 108 of file METTester.h.

◆ mMETUnc_TauEnDown

MonitorElement* METTester::mMETUnc_TauEnDown
private

Definition at line 105 of file METTester.h.

◆ mMETUnc_TauEnUp

MonitorElement* METTester::mMETUnc_TauEnUp
private

Definition at line 104 of file METTester.h.

◆ mMETUnc_UnclusteredEnDown

MonitorElement* METTester::mMETUnc_UnclusteredEnDown
private

Definition at line 107 of file METTester.h.

◆ mMETUnc_UnclusteredEnUp

MonitorElement* METTester::mMETUnc_UnclusteredEnUp
private

Definition at line 106 of file METTester.h.

◆ mMEx

MonitorElement* METTester::mMEx
private

Definition at line 82 of file METTester.h.

◆ mMEy

MonitorElement* METTester::mMEy
private

Definition at line 83 of file METTester.h.

◆ mMuonEtFraction

MonitorElement* METTester::mMuonEtFraction
private

Definition at line 134 of file METTester.h.

◆ mNeutralEMEtFraction

MonitorElement* METTester::mNeutralEMEtFraction
private

Definition at line 130 of file METTester.h.

◆ mNeutralHadEtFraction

MonitorElement* METTester::mNeutralHadEtFraction
private

Definition at line 131 of file METTester.h.

◆ mNvertex

MonitorElement* METTester::mNvertex
private

Definition at line 79 of file METTester.h.

◆ mPFchargedHadronEt

MonitorElement* METTester::mPFchargedHadronEt
private

Definition at line 147 of file METTester.h.

◆ mPFchargedHadronEtFraction

MonitorElement* METTester::mPFchargedHadronEtFraction
private

Definition at line 146 of file METTester.h.

◆ mPFelectronEt

MonitorElement* METTester::mPFelectronEt
private

Definition at line 145 of file METTester.h.

◆ mPFelectronEtFraction

MonitorElement* METTester::mPFelectronEtFraction
private

Definition at line 144 of file METTester.h.

◆ mPFHFEMEt

MonitorElement* METTester::mPFHFEMEt
private

Definition at line 153 of file METTester.h.

◆ mPFHFEMEtFraction

MonitorElement* METTester::mPFHFEMEtFraction
private

Definition at line 152 of file METTester.h.

◆ mPFHFHadronEt

MonitorElement* METTester::mPFHFHadronEt
private

Definition at line 151 of file METTester.h.

◆ mPFHFHadronEtFraction

MonitorElement* METTester::mPFHFHadronEtFraction
private

Definition at line 150 of file METTester.h.

◆ mPFmuonEt

MonitorElement* METTester::mPFmuonEt
private

Definition at line 149 of file METTester.h.

◆ mPFmuonEtFraction

MonitorElement* METTester::mPFmuonEtFraction
private

Definition at line 148 of file METTester.h.

◆ mPFneutralHadronEt

MonitorElement* METTester::mPFneutralHadronEt
private

Definition at line 143 of file METTester.h.

◆ mPFneutralHadronEtFraction

MonitorElement* METTester::mPFneutralHadronEtFraction
private

Definition at line 142 of file METTester.h.

◆ mPFphotonEt

MonitorElement* METTester::mPFphotonEt
private

Definition at line 141 of file METTester.h.

◆ mPFphotonEtFraction

MonitorElement* METTester::mPFphotonEtFraction
private

Definition at line 140 of file METTester.h.

◆ mSumET

MonitorElement* METTester::mSumET
private

Definition at line 89 of file METTester.h.

◆ patMETToken_

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

Definition at line 76 of file METTester.h.

◆ pfMETsToken_

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

Definition at line 71 of file METTester.h.

◆ pvToken_

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

Definition at line 69 of file METTester.h.

METTester::mMETDifference_GenMETTrue
MonitorElement * mMETDifference_GenMETTrue
Definition: METTester.h:90
pat::MET::NeutralEMFraction
double NeutralEMFraction() const
Definition: MET.h:137
METTester::mMETDifference_GenMETTrue_MET200to300
MonitorElement * mMETDifference_GenMETTrue_MET200to300
Definition: METTester.h:162
METTester::isPFMET
bool isPFMET
Definition: METTester.h:172
METTester::mMETDifference_GenMETTrue_MET60to80
MonitorElement * mMETDifference_GenMETTrue_MET60to80
Definition: METTester.h:158
reco::PFMET::muonEtFraction
double muonEtFraction() const
Definition: PFMET.h:43
METTester::mMETUnc_UnclusteredEnDown
MonitorElement * mMETUnc_UnclusteredEnDown
Definition: METTester.h:107
METTester::mMETFine
MonitorElement * mMETFine
Definition: METTester.h:86
reco::CaloMET::emEtFraction
double emEtFraction() const
Definition: CaloMET.h:43
edm::Handle::product
T const * product() const
Definition: Handle.h:70
reco::PFMET::neutralHadronEtFraction
double neutralHadronEtFraction() const
Definition: PFMET.h:34
METTester::mCaloHadEtInHO
MonitorElement * mCaloHadEtInHO
Definition: METTester.h:118
METTester::mMETUnc_TauEnUp
MonitorElement * mMETUnc_TauEnUp
Definition: METTester.h:104
METTester::mMETDifference_GenMETTrue_MET20to40
MonitorElement * mMETDifference_GenMETTrue_MET20to40
Definition: METTester.h:156
reco::CaloMET::etFractionHadronic
double etFractionHadronic() const
Definition: CaloMET.h:41
pat::MET::JetEnDown
Definition: MET.h:156
METTester::mPFHFHadronEtFraction
MonitorElement * mPFHFHadronEtFraction
Definition: METTester.h:150
METTester::mMETUnc_UnclusteredEnUp
MonitorElement * mMETUnc_UnclusteredEnUp
Definition: METTester.h:106
pat::MET::ChargedHadEtFraction
double ChargedHadEtFraction() const
Definition: MET.h:140
reco::CaloMET::maxEtInEmTowers
double maxEtInEmTowers() const
Definition: CaloMET.h:37
pat::MET::isPFMET
bool isPFMET() const
True if this pat::MET was made from a reco::pfMET.
Definition: MET.h:88
gather_cfg.cout
cout
Definition: gather_cfg.py:144
METTester::caloMETsToken_
edm::EDGetTokenT< reco::CaloMETCollection > caloMETsToken_
Definition: METTester.h:70
METTester::mMETUnc_MuonEnDown
MonitorElement * mMETUnc_MuonEnDown
Definition: METTester.h:101
reco::PFMET::HFEMEt
double HFEMEt() const
Definition: PFMET.h:50
METTester::mMETDifference_GenMETTrue_MET150to200
MonitorElement * mMETDifference_GenMETTrue_MET150to200
Definition: METTester.h:161
pat::MET::PhotonEnDown
Definition: MET.h:166
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
reco::PFMET::chargedHadronEt
double chargedHadronEt() const
Definition: PFMET.h:41
reco::CaloMET::emEtInHF
double emEtInHF() const
Definition: CaloMET.h:57
pat::MET::shiftedPt
double shiftedPt(METUncertainty shift, METCorrectionLevel level=Type1) const
Definition: MET.h:224
METTester::mNeutralHadEtFraction
MonitorElement * mNeutralHadEtFraction
Definition: METTester.h:131
reco::PFMET::HFHadronEt
double HFHadronEt() const
Definition: PFMET.h:47
cms::cuda::assert
assert(be >=bs)
METTester::mMET_Nvtx
MonitorElement * mMET_Nvtx
Definition: METTester.h:87
METTester::mPFHFEMEt
MonitorElement * mPFHFEMEt
Definition: METTester.h:153
METTester::mCaloEmEtInEE
MonitorElement * mCaloEmEtInEE
Definition: METTester.h:126
reco::CaloMET::CaloSETInpHF
double CaloSETInpHF() const
Definition: CaloMET.h:61
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
pat::MET::MuonEtFraction
double MuonEtFraction() const
Definition: MET.h:141
RazorAnalyzer.genmet
genmet
do same things for GEN
Definition: RazorAnalyzer.py:121
reco::CaloMET::hadEtInHO
double hadEtInHO() const
Definition: CaloMET.h:47
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
METTester::inputMETLabel_
edm::InputTag inputMETLabel_
Definition: METTester.h:63
METTester::mMETUnc_MuonEnUp
MonitorElement * mMETUnc_MuonEnUp
Definition: METTester.h:100
edm::Handle< reco::VertexCollection >
pat::MET::TauEnDown
Definition: MET.h:162
METTester::mPFHFEMEtFraction
MonitorElement * mPFHFEMEtFraction
Definition: METTester.h:152
pat::MET::Type6EtFraction
double Type6EtFraction() const
Definition: MET.h:142
METTester::mMETPhi
MonitorElement * mMETPhi
Definition: METTester.h:88
METTester::mCaloEmEtInHF
MonitorElement * mCaloEmEtInHF
Definition: METTester.h:123
METTester::isMiniAODMET
bool isMiniAODMET
Definition: METTester.h:174
reco::PFMET::photonEtFraction
double photonEtFraction() const
Definition: PFMET.h:31
METTester::mCaloHadEtInHF
MonitorElement * mCaloHadEtInHF
Definition: METTester.h:120
BTaggingMonitor_cfi.met
met
Definition: BTaggingMonitor_cfi.py:84
METTester::mMEx
MonitorElement * mMEx
Definition: METTester.h:82
pat::MET::JetResUp
Definition: MET.h:153
METTester::mMETSig
MonitorElement * mMETSig
Definition: METTester.h:84
reco::CaloMET
Definition: CaloMET.h:21
METTester::mCaloMaxEtInHadTowers
MonitorElement * mCaloMaxEtInHadTowers
Definition: METTester.h:114
METTester::mPFchargedHadronEt
MonitorElement * mPFchargedHadronEt
Definition: METTester.h:147
reco::PFMET::electronEt
double electronEt() const
Definition: PFMET.h:38
METTester::mCaloEtFractionHadronic
MonitorElement * mCaloEtFractionHadronic
Definition: METTester.h:115
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
METTester::genMETsToken_
edm::EDGetTokenT< reco::GenMETCollection > genMETsToken_
Definition: METTester.h:73
pat::MET::PhotonEnUp
Definition: MET.h:165
reco::MET
Definition: MET.h:41
METTester::mMETUnc_TauEnDown
MonitorElement * mMETUnc_TauEnDown
Definition: METTester.h:105
reco::GenMET
Definition: GenMET.h:20
reco::CaloMET::maxEtInHadTowers
double maxEtInHadTowers() const
Definition: CaloMET.h:39
pat::MET::TauEnUp
Definition: MET.h:161
METTester::mMuonEtFraction
MonitorElement * mMuonEtFraction
Definition: METTester.h:134
METTester::mNeutralEMEtFraction
MonitorElement * mNeutralEMEtFraction
Definition: METTester.h:130
METTester::mMETDifference_GenMETTrue_MET100to150
MonitorElement * mMETDifference_GenMETTrue_MET100to150
Definition: METTester.h:160
pat::MET::ChargedEMEtFraction
double ChargedEMEtFraction() const
Definition: MET.h:139
METTester::mCaloHadEtInHB
MonitorElement * mCaloHadEtInHB
Definition: METTester.h:117
reco::PFMET::neutralHadronEt
double neutralHadronEt() const
Definition: PFMET.h:35
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
METTester::mMET
MonitorElement * mMET
Definition: METTester.h:85
METTester::mChargedHadEtFraction
MonitorElement * mChargedHadEtFraction
Definition: METTester.h:133
pat::MET::ElectronEnDown
Definition: MET.h:160
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
METTester::mMETDifference_GenMETTrue_MET80to100
MonitorElement * mMETDifference_GenMETTrue_MET80to100
Definition: METTester.h:159
METTester::mMETDeltaPhi_GenMETTrue
MonitorElement * mMETDeltaPhi_GenMETTrue
Definition: METTester.h:91
reco::PFMET::HFEMEtFraction
double HFEMEtFraction() const
Definition: PFMET.h:49
METTester::mCaloEmEtInEB
MonitorElement * mCaloEmEtInEB
Definition: METTester.h:127
METTester::genMETsTrueToken_
edm::EDGetTokenT< reco::GenMETCollection > genMETsTrueToken_
Definition: METTester.h:74
METTester::mPFelectronEtFraction
MonitorElement * mPFelectronEtFraction
Definition: METTester.h:144
METTester::mPFmuonEtFraction
MonitorElement * mPFmuonEtFraction
Definition: METTester.h:148
METTester::mMETUnc_PhotonEnUp
MonitorElement * mMETUnc_PhotonEnUp
Definition: METTester.h:108
METTester::mMEy
MonitorElement * mMEy
Definition: METTester.h:83
reco::PFMET
Definition: PFMET.h:18
pat::MET::JetResDown
Definition: MET.h:154
METTester::mPFphotonEtFraction
MonitorElement * mPFphotonEtFraction
Definition: METTester.h:140
reco::PFMET::HFHadronEtFraction
double HFHadronEtFraction() const
Definition: PFMET.h:46
reco::CaloMET::emEtInEE
double emEtInEE() const
Definition: CaloMET.h:55
METTester::isGenMET
bool isGenMET
Definition: METTester.h:173
pat::MET::NeutralHadEtFraction
double NeutralHadEtFraction() const
Definition: MET.h:138
METTester::mPFneutralHadronEtFraction
MonitorElement * mPFneutralHadronEtFraction
Definition: METTester.h:142
reco::CaloMET::hadEtInHB
double hadEtInHB() const
Definition: CaloMET.h:45
METTester::pfMETsToken_
edm::EDGetTokenT< reco::PFMETCollection > pfMETsToken_
Definition: METTester.h:71
iEvent
int iEvent
Definition: GenABIO.cc:224
METTester::mPFHFHadronEt
MonitorElement * mPFHFHadronEt
Definition: METTester.h:151
METTester::mMETDifference_GenMETTrue_MET0to20
MonitorElement * mMETDifference_GenMETTrue_MET0to20
Definition: METTester.h:155
METTester::patMETToken_
edm::EDGetTokenT< pat::METCollection > patMETToken_
Definition: METTester.h:76
pat::MET
Analysis-level MET class.
Definition: MET.h:40
METTester::mMETUnc_JetResUp
MonitorElement * mMETUnc_JetResUp
Definition: METTester.h:96
METTester::mNvertex
MonitorElement * mNvertex
Definition: METTester.h:79
reco::CaloMET::emEtInEB
double emEtInEB() const
Definition: CaloMET.h:53
METTester::METType_
std::string METType_
Definition: METTester.h:64
reco::PFMET::electronEtFraction
double electronEtFraction() const
Definition: PFMET.h:37
pat::MET::MuonEnDown
Definition: MET.h:158
METTester::mCaloSETInpHF
MonitorElement * mCaloSETInpHF
Definition: METTester.h:124
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
METTester::mMETUnc_ElectronEnUp
MonitorElement * mMETUnc_ElectronEnUp
Definition: METTester.h:102
reco::CaloMET::hadEtInHE
double hadEtInHE() const
Definition: CaloMET.h:49
METTester::mMETDifference_GenMETTrue_MET300to400
MonitorElement * mMETDifference_GenMETTrue_MET300to400
Definition: METTester.h:163
METTester::mPFphotonEt
MonitorElement * mPFphotonEt
Definition: METTester.h:141
METTester::mMETUnc_JetEnDown
MonitorElement * mMETUnc_JetEnDown
Definition: METTester.h:99
METTester::mMETDeltaPhi_GenMETCalo
MonitorElement * mMETDeltaPhi_GenMETCalo
Definition: METTester.h:93
METTester::mMETDifference_GenMETTrue_MET500
MonitorElement * mMETDifference_GenMETTrue_MET500
Definition: METTester.h:165
pat::MET::ElectronEnUp
Definition: MET.h:159
METTester::mCaloSETInmHF
MonitorElement * mCaloSETInmHF
Definition: METTester.h:125
METTester::mPFchargedHadronEtFraction
MonitorElement * mPFchargedHadronEtFraction
Definition: METTester.h:146
METTester::mMETUnc_JetEnUp
MonitorElement * mMETUnc_JetEnUp
Definition: METTester.h:98
reco::PFMET::photonEt
double photonEt() const
Definition: PFMET.h:32
METTester::mInvisibleEtFraction
MonitorElement * mInvisibleEtFraction
Definition: METTester.h:135
reco::CaloMET::CaloSETInmHF
double CaloSETInmHF() const
Definition: CaloMET.h:63
METTester::mSumET
MonitorElement * mSumET
Definition: METTester.h:89
reco::PFMET::chargedHadronEtFraction
double chargedHadronEtFraction() const
Definition: PFMET.h:40
genMetTrue_cfi.genMetTrue
genMetTrue
____________________________________________________________________________||
Definition: genMetTrue_cfi.py:4
pat::MET::UnclusteredEnUp
Definition: MET.h:163
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
METTester::mCaloMaxEtInEmTowers
MonitorElement * mCaloMaxEtInEmTowers
Definition: METTester.h:113
pat::MET::JetEnUp
Definition: MET.h:155
pat::MET::MuonEnUp
Definition: MET.h:157
METTester::mMETDifference_GenMETCalo
MonitorElement * mMETDifference_GenMETCalo
Definition: METTester.h:92
METTester::mChargedEMEtFraction
MonitorElement * mChargedEMEtFraction
Definition: METTester.h:132
genMetCalo_cfi.genMetCalo
genMetCalo
____________________________________________________________________________||
Definition: genMetCalo_cfi.py:4
reco::PFMET::muonEt
double muonEt() const
Definition: PFMET.h:44
METTester::genMETsCaloToken_
edm::EDGetTokenT< reco::GenMETCollection > genMETsCaloToken_
Definition: METTester.h:75
GenMETCollection
Collection of Gen MET.
METTester::mMETUnc_PhotonEnDown
MonitorElement * mMETUnc_PhotonEnDown
Definition: METTester.h:109
METTester::isCaloMET
bool isCaloMET
Definition: METTester.h:169
METTester::mCaloHadEtInHE
MonitorElement * mCaloHadEtInHE
Definition: METTester.h:119
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
pat::MET::UnclusteredEnDown
Definition: MET.h:164
METTester::pvToken_
edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
Definition: METTester.h:69
pat::MET::Type7EtFraction
double Type7EtFraction() const
Definition: MET.h:143
METTester::mPFneutralHadronEt
MonitorElement * mPFneutralHadronEt
Definition: METTester.h:143
METTester::mMETUnc_JetResDown
MonitorElement * mMETUnc_JetResDown
Definition: METTester.h:97
METTester::mMETUnc_ElectronEnDown
MonitorElement * mMETUnc_ElectronEnDown
Definition: METTester.h:103
edm::InputTag
Definition: InputTag.h:15
METTester::mCaloEmEtFraction
MonitorElement * mCaloEmEtFraction
Definition: METTester.h:116
METTester::mMETDifference_GenMETTrue_MET40to60
MonitorElement * mMETDifference_GenMETTrue_MET40to60
Definition: METTester.h:157
METTester::mMETDifference_GenMETTrue_MET400to500
MonitorElement * mMETDifference_GenMETTrue_MET400to500
Definition: METTester.h:164
METTester::mPFelectronEt
MonitorElement * mPFelectronEt
Definition: METTester.h:145
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
METTester::mPFmuonEt
MonitorElement * mPFmuonEt
Definition: METTester.h:149
reco::CaloMET::hadEtInHF
double hadEtInHF() const
Definition: CaloMET.h:51
Generated for CMSSW Reference Manual by doxygen 1.8.16