#include <MatchMETBenchmark.h>

Inheritance diagram for MatchMETBenchmark:

Public Member Functions
void	fillOne (const reco::MET &candidate, const reco::MET &matchedCandidate)
	fill histograms with a given particle More...

	MatchMETBenchmark (Mode mode)

void	setup (DQMStore::IBooker &b)
	book histograms More...

	~MatchMETBenchmark () override

Public Member Functions inherited from Benchmark
	Benchmark (Mode mode=DEFAULT)

bool	isInRange (float pt, float eta, float phi) const

virtual void	setDirectory (TDirectory *dir)

void	setParameters (Mode mode)

void	setRange (float ptMin, float ptMax, float etaMin, float etaMax, float phiMin, float phiMax)

void	write ()

virtual	~Benchmark ()(false)

Protected Attributes
TH2F *	delta_et_Over_et_VS_et_

TH2F *	delta_et_VS_et_

TH1F *	delta_ex_

TH2F *	delta_ex_VS_set_

TH2F *	delta_phi_VS_et_

TH2F *	delta_set_Over_set_VS_set_

TH2F *	delta_set_VS_set_

TH2F *	RecEt_VS_TrueEt_

TH2F *	RecSet_Over_TrueSet_VS_TrueSet_

Protected Attributes inherited from Benchmark
TDirectory *	dir_

float	etaMax_

float	etaMin_

Mode	mode_

float	phiMax_

float	phiMin_

float	ptMax_

float	ptMin_

Additional Inherited Members
Public Types inherited from Benchmark
enum	Mode { DEFAULT, DQMOFFLINE, VALIDATION }

Protected Member Functions inherited from Benchmark
TH1F *	book1D (DQMStore::IBooker &b, const char histname, const char title, int nbins, float xmin, float xmax)
	book a 1D histogram, either through IBooker or plain root More...

TH2F *	book2D (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xmin, float xmax, int nbinsy, float ymin, float ymax)
	book a 2D histogram, either through IBooker or plain root More...

TH2F *	book2D (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float *xbins, int nbinsy, float ymin, float ymax)
	book a 2D histogram, either through IBooker or plain root More...

TProfile *	bookProfile (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xmin, float xmax, float ymin, float ymax, const char *option)
	book a TProfile, either through IBooker or plain root More...

TProfile *	bookProfile (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xbins, float ymin, float ymax, const char option)
	book a TProfile, either through IBooker or plain root More...

Detailed Description

Definition at line 13 of file MatchMETBenchmark.h.

Constructor & Destructor Documentation

MatchMETBenchmark::MatchMETBenchmark ( Mode mode )

inline

Definition at line 15 of file MatchMETBenchmark.h.

References b, fillOne(), setup(), and ~MatchMETBenchmark().

15 : Benchmark(mode) {}

ALCARECOPromptCalibProdSiPixelAli0T_cff.mode

mode

Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96

Benchmark::Benchmark

Benchmark(Mode mode=DEFAULT)

Definition: Benchmark.h:34

MatchMETBenchmark::~MatchMETBenchmark ( )

override

Definition at line 13 of file MatchMETBenchmark.cc.

Referenced by MatchMETBenchmark().

13 {}

Member Function Documentation

void MatchMETBenchmark::fillOne	(	const reco::MET &	candidate,
		const reco::MET &	matchedCandidate
	)

fill histograms with a given particle

Definition at line 106 of file MatchMETBenchmark.cc.

References reco::LeafCandidate::eta(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), and reco::MET::sumEt().

Referenced by MatchMETBenchmarkAnalyzer::analyze(), and MatchMETBenchmark().

                                                                                {
   if (!isInRange(cand.pt(), cand.eta(), cand.phi()))
     return;
 
   if (matchedCand.pt() > 0.001)
     delta_et_Over_et_VS_et_->Fill(matchedCand.pt(), (cand.pt() - matchedCand.pt()) / matchedCand.pt());
   else
     edm::LogWarning("MatchMETBenchmark") << " matchedCand.pt()<0.001";
   delta_et_VS_et_->Fill(matchedCand.pt(), cand.pt() - matchedCand.pt());
   delta_phi_VS_et_->Fill(matchedCand.pt(), cand.phi() - matchedCand.phi());
   delta_ex_->Fill(cand.px() - matchedCand.px());
   delta_ex_->Fill(cand.py() - matchedCand.py());
   RecEt_VS_TrueEt_->Fill(matchedCand.pt(), cand.pt());
   delta_set_VS_set_->Fill(matchedCand.sumEt(), cand.sumEt() - matchedCand.sumEt());
   if (matchedCand.sumEt() > 0.001)
     delta_set_Over_set_VS_set_->Fill(matchedCand.sumEt(), (cand.sumEt() - matchedCand.sumEt()) / matchedCand.sumEt());
   else
     edm::LogWarning("MatchMETBenchmark") << " matchedCand.sumEt()<0.001";
   delta_ex_VS_set_->Fill(matchedCand.sumEt(), cand.px() - matchedCand.px());
   delta_ex_VS_set_->Fill(matchedCand.sumEt(), cand.py() - matchedCand.py());
   if (matchedCand.sumEt() > 0.001)
     RecSet_Over_TrueSet_VS_TrueSet_->Fill(matchedCand.sumEt(), cand.sumEt() / matchedCand.sumEt());
 }

void MatchMETBenchmark::setup ( DQMStore::IBooker & b )

book histograms

Definition at line 15 of file MatchMETBenchmark.cc.

References Benchmark::PhaseSpace::m, Benchmark::PhaseSpace::M, and Benchmark::PhaseSpace::n.

Referenced by MatchMETBenchmarkAnalyzer::bookHistograms(), and MatchMETBenchmark().

                                                 {
   // std::cout << "FL: MatchMETBenchmark.cc: start setup()" << std::endl;
   PhaseSpace ptPS;
   PhaseSpace dptOvptPS;
   PhaseSpace dptPS;
   PhaseSpace dphiPS;
   PhaseSpace setPS;
   PhaseSpace dsetPS;
   PhaseSpace setOvsetPS;
 
   switch (mode_) {
     case VALIDATION:
       ptPS = PhaseSpace(100, 0, 1000);
       dptOvptPS = PhaseSpace(200, -1, 1);
       dphiPS = PhaseSpace(100, -3.2, 3.2);
       dptPS = PhaseSpace(200, -500, 500);
       setPS = PhaseSpace(300, 0.0, 3000);
       dsetPS = PhaseSpace(200, 0. - 1000, 1000);
       setOvsetPS = PhaseSpace(500, 0., 2.);
       break;
     case DQMOFFLINE:
     default:
       ptPS = PhaseSpace(50, 0, 200);
       dptOvptPS = PhaseSpace(50, -1, 1);
       dphiPS = PhaseSpace(50, -3.2, 3.2);
       dptPS = PhaseSpace(50, -500, 500);
       setPS = PhaseSpace(50, 0.0, 3000);
       dsetPS = PhaseSpace(50, -1000.0, 1000);
       setOvsetPS = PhaseSpace(100, 0., 2.);
       break;
   }
 
   // variable bins to be done here, as they will save a lot of memory.
 
   // float ptBins[11] = {0, 1, 2, 5, 10, 20, 50, 100, 200, 400, 1000};
 
   delta_et_Over_et_VS_et_ = book2D(b,
                                    "delta_et_Over_et_VS_et_",
                                    ";ME_{T, true} (GeV);#DeltaME_{T}/ME_{T}",
                                    ptPS.n,
                                    ptPS.m,
                                    ptPS.M,
                                    dptOvptPS.n,
                                    dptOvptPS.m,
                                    dptOvptPS.M);
 
   delta_et_VS_et_ = book2D(
       b, "delta_et_VS_et_", ";ME_{T, true} (GeV);#DeltaME_{T}", ptPS.n, ptPS.m, ptPS.M, dptPS.n, dptPS.m, dptPS.M);
 
   delta_phi_VS_et_ = book2D(
       b, "delta_phi_VS_et_", ";ME_{T, true} (GeV);#Delta#phi", ptPS.n, ptPS.m, ptPS.M, dphiPS.n, dphiPS.m, dphiPS.M);
 
   delta_ex_ = book1D(b, "delta_ex_", "#DeltaME_{X}", dptPS.n, dptPS.m, dptPS.M);
 
   RecEt_VS_TrueEt_ =
       book2D(b, "RecEt_VS_TrueEt_", ";ME_{T, true} (GeV);ME_{T}", ptPS.n, ptPS.m, ptPS.M, ptPS.n, ptPS.m, ptPS.M);
 
   delta_set_VS_set_ = book2D(b,
                              "delta_set_VS_set_",
                              ";SE_{T, true} (GeV);#DeltaSE_{T}",
                              setPS.n,
                              setPS.m,
                              setPS.M,
                              dsetPS.n,
                              dsetPS.m,
                              dsetPS.M);
 
   delta_set_Over_set_VS_set_ = book2D(b,
                                       "delta_set_Over_set_VS_set_",
                                       ";SE_{T, true} (GeV);#DeltaSE_{T}/SE_{T}",
                                       setPS.n,
                                       setPS.m,
                                       setPS.M,
                                       dptOvptPS.n,
                                       dptOvptPS.m,
                                       dptOvptPS.M);
 
   delta_ex_VS_set_ = book2D(
       b, "delta_ex_VS_set_", ";SE_{T, true} (GeV);#DeltaE_{X}", setPS.n, setPS.m, setPS.M, ptPS.n, -ptPS.M, ptPS.M);
 
   RecSet_Over_TrueSet_VS_TrueSet_ = book2D(b,
                                            "RecSet_Over_TrueSet_VS_TrueSet_",
                                            ";SE_{T, true} (GeV);SE_{T}/SE_{T}",
                                            setPS.n,
                                            setPS.m,
                                            setPS.M,
                                            setOvsetPS.n,
                                            setOvsetPS.m,
                                            setOvsetPS.M);
 }

Member Data Documentation

TH2F* MatchMETBenchmark::delta_et_Over_et_VS_et_

protected

Definition at line 28 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::delta_et_VS_et_

protected

Definition at line 27 of file MatchMETBenchmark.h.

TH1F* MatchMETBenchmark::delta_ex_

protected

Definition at line 32 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::delta_ex_VS_set_

protected

Definition at line 38 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::delta_phi_VS_et_

protected

Definition at line 30 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::delta_set_Over_set_VS_set_

protected

Definition at line 37 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::delta_set_VS_set_

protected

Definition at line 36 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::RecEt_VS_TrueEt_

protected

Definition at line 35 of file MatchMETBenchmark.h.

TH2F* MatchMETBenchmark::RecSet_Over_TrueSet_VS_TrueSet_

protected

Definition at line 41 of file MatchMETBenchmark.h.

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation