#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 ()
	write to the TFile, in plain ROOT mode. No need to call this function in DQM mode More...

virtual	~Benchmark () noexcept(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
typedef dqm::legacy::DQMStore	DQMStore

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 with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. 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 with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. 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 with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. 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...

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 histogram, either with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. More...

Detailed Description

Definition at line 13 of file MatchMETBenchmark.h.

Constructor & Destructor Documentation

◆ MatchMETBenchmark()

MatchMETBenchmark::MatchMETBenchmark ( Mode mode )

inline

Definition at line 15 of file MatchMETBenchmark.h.

15 : Benchmark(mode) {}

◆ ~MatchMETBenchmark()

MatchMETBenchmark::~MatchMETBenchmark ( )

override

Definition at line 13 of file MatchMETBenchmark.cc.

13 {}

Member Function Documentation

◆ fillOne()

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.

                                                                                {
   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());
 }

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

Referenced by MatchMETBenchmarkAnalyzer::analyze().

◆ setup()

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

book histograms

Definition at line 15 of file MatchMETBenchmark.cc.

                                                 {
   // 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);
 }

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

Referenced by MatchMETBenchmarkAnalyzer::bookHistograms().

Member Data Documentation

◆ delta_et_Over_et_VS_et_

TH2F* MatchMETBenchmark::delta_et_Over_et_VS_et_

protected

Definition at line 28 of file MatchMETBenchmark.h.

◆ delta_et_VS_et_

TH2F* MatchMETBenchmark::delta_et_VS_et_

protected

Definition at line 27 of file MatchMETBenchmark.h.

◆ delta_ex_

TH1F* MatchMETBenchmark::delta_ex_

protected

Definition at line 32 of file MatchMETBenchmark.h.

◆ delta_ex_VS_set_

TH2F* MatchMETBenchmark::delta_ex_VS_set_

protected

Definition at line 38 of file MatchMETBenchmark.h.

◆ delta_phi_VS_et_

TH2F* MatchMETBenchmark::delta_phi_VS_et_

protected

Definition at line 30 of file MatchMETBenchmark.h.

◆ delta_set_Over_set_VS_set_

TH2F* MatchMETBenchmark::delta_set_Over_set_VS_set_

protected

Definition at line 37 of file MatchMETBenchmark.h.

◆ delta_set_VS_set_

TH2F* MatchMETBenchmark::delta_set_VS_set_

protected

Definition at line 36 of file MatchMETBenchmark.h.

◆ RecEt_VS_TrueEt_

TH2F* MatchMETBenchmark::RecEt_VS_TrueEt_

protected

Definition at line 35 of file MatchMETBenchmark.h.

◆ RecSet_Over_TrueSet_VS_TrueSet_

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

◆ MatchMETBenchmark()

◆ ~MatchMETBenchmark()

Member Function Documentation

◆ fillOne()

◆ setup()

Member Data Documentation

◆ delta_et_Over_et_VS_et_

◆ delta_et_VS_et_

◆ delta_ex_

◆ delta_ex_VS_set_

◆ delta_phi_VS_et_

◆ delta_set_Over_set_VS_set_

◆ delta_set_VS_set_

◆ RecEt_VS_TrueEt_

◆ RecSet_Over_TrueSet_VS_TrueSet_