#include <PFMETMonitor.h>

Inheritance diagram for PFMETMonitor:

Public Member Functions
void	fillOne (const reco::MET &met, const reco::MET &matchedMet, float &minVal, float &maxVal)

	PFMETMonitor (Benchmark::Mode mode=Benchmark::DEFAULT)

void	setDirectory (TDirectory *dir)
	set directory (to use in ROOT) More...

void	setParameters (Benchmark::Mode mode, float ptmin, float ptmax, float etamin, float etamax, float phimin, float phimax, bool metSpHistos)
	set the parameters locally More...

void	setParameters (const edm::ParameterSet &parameterSet)
	set the parameters accessing them from ParameterSet More...

void	setup ()
	book histograms More...

void	setup (const edm::ParameterSet &parameterSet)
	book histograms More...

virtual	~PFMETMonitor ()

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

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

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 ()

Protected Attributes
CandidateBenchmark	candBench_

bool	createMETSpecificHistos_

TH1F *	delta_ex_

TH2F *	delta_ex_VS_set_

TH2F *	delta_set_Over_set_VS_set_

TH2F *	delta_set_VS_set_

bool	histogramBooked_

MatchCandidateBenchmark	matchCandBench_

TH1F *	px_

TH1F *	sumEt_

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 }

Static Public Attributes inherited from Benchmark
static DQMStore *	DQM_ = 0

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

TH2F *	book2D (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. More...

TH2F *	book2D (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. More...

Detailed Description

Definition at line 11 of file PFMETMonitor.h.

Constructor & Destructor Documentation

PFMETMonitor::PFMETMonitor ( Benchmark::Mode mode = Benchmark::DEFAULT )

Definition at line 15 of file PFMETMonitor.cc.

References createMETSpecificHistos_, delta_ex_, delta_ex_VS_set_, delta_set_Over_set_VS_set_, delta_set_VS_set_, histogramBooked_, px_, Benchmark::setRange(), and sumEt_.

                                               : 
    Benchmark(mode), 
    candBench_(mode), 
    matchCandBench_(mode) {
 
   setRange( 0.0, 10e10, -10.0, 10.0, -3.14, 3.14);
 
   px_                        = 0;
   sumEt_                     = 0;
   delta_ex_                  = 0;
   delta_ex_VS_set_           = 0;
   delta_set_VS_set_          = 0;
   delta_set_Over_set_VS_set_ = 0;
   
   createMETSpecificHistos_ = false;
   histogramBooked_ = false;
 } 

PFMETMonitor::~PFMETMonitor ( )

virtual

Definition at line 35 of file PFMETMonitor.cc.

35 {}

Member Function Documentation

void PFMETMonitor::fillOne	(	const reco::MET &	met,
		const reco::MET &	matchedMet,
		float &	minVal,
		float &	maxVal
	)

Definition at line 182 of file PFMETMonitor.cc.

References candBench_, createMETSpecificHistos_, delta_ex_, delta_ex_VS_set_, delta_set_Over_set_VS_set_, delta_set_VS_set_, reco::LeafCandidate::eta(), CandidateBenchmark::fillOne(), MatchCandidateBenchmark::fillOne(), histogramBooked_, Benchmark::isInRange(), matchCandBench_, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), px_, reco::LeafCandidate::py(), reco::MET::sumEt(), and sumEt_.

Referenced by PFMETDQMAnalyzer::analyze(), and PFRootEventManager::processEntry().

                                                                         {
   candBench_.fillOne(met);
   matchCandBench_.fillOne(met, matchedMet);
   if (createMETSpecificHistos_ && histogramBooked_) {
     if( !isInRange(met.pt(), met.eta(), met.phi() ) ) return;
 
     if (px_) px_->Fill(met.px());
     if (delta_ex_) {
       delta_ex_->Fill(met.px()-matchedMet.px());
       delta_ex_->Fill(met.py()-matchedMet.py());
     }
     if (sumEt_) sumEt_->Fill( met.sumEt());
 
     if (delta_ex_VS_set_) {
       delta_ex_VS_set_->Fill(matchedMet.sumEt(), met.px()-matchedMet.px());
       delta_ex_VS_set_->Fill(matchedMet.sumEt(), met.py()-matchedMet.py());
     }
     if (delta_set_VS_set_) delta_set_VS_set_->Fill(matchedMet.sumEt(),met.sumEt()-matchedMet.sumEt());
     if (delta_set_Over_set_VS_set_ &&  matchedMet.sumEt()>0.001 ) {
       float setRes = (met.sumEt() - matchedMet.sumEt())/matchedMet.sumEt();
       if (setRes > maxVal) maxVal = setRes;
       if (setRes < minVal) minVal = setRes;    
       delta_set_Over_set_VS_set_->Fill(matchedMet.sumEt(),setRes);
     }
   } 
 }

void PFMETMonitor::setDirectory ( TDirectory * dir )

virtual

set directory (to use in ROOT)

Reimplemented from Benchmark.

Definition at line 175 of file PFMETMonitor.cc.

References candBench_, matchCandBench_, and Benchmark::setDirectory().

Referenced by PFRootEventManager::readOptions().

                                                {
   Benchmark::setDirectory(dir);
 
   candBench_.setDirectory(dir);
   matchCandBench_.setDirectory(dir);
 }

void PFMETMonitor::setParameters	(	Benchmark::Mode	mode,
		float	ptmin,
		float	ptmax,
		float	etamin,
		float	etamax,
		float	phimin,
		float	phimax,
		bool	metSpHistos
	)

set the parameters locally

Definition at line 58 of file PFMETMonitor.cc.

References candBench_, createMETSpecificHistos_, matchCandBench_, alignBH_cfg::mode, Benchmark::mode_, Benchmark::setParameters(), and Benchmark::setRange().

Referenced by PFMETDQMAnalyzer::PFMETDQMAnalyzer(), and PFRootEventManager::readOptions().

                                                  {
   mode_           = mode;
   createMETSpecificHistos_ = metSpHistos;
 
   setRange( ptmin, ptmax, etamin, etamax, phimin, phimax);
 
   candBench_.setParameters(mode_);
   matchCandBench_.setParameters(mode_);  
 }

void PFMETMonitor::setParameters ( const edm::ParameterSet & parameterSet )

set the parameters accessing them from ParameterSet

Definition at line 40 of file PFMETMonitor.cc.

References candBench_, createMETSpecificHistos_, edm::ParameterSet::getParameter(), matchCandBench_, Benchmark::mode_, Benchmark::setParameters(), and Benchmark::setRange().

                                                                       {
   
   mode_           = (Benchmark::Mode) parameterSet.getParameter<int>( "mode" );
   createMETSpecificHistos_ = parameterSet.getParameter<bool>( "CreateMETSpecificHistos" );
   setRange( parameterSet.getParameter<double>("ptMin"),
         parameterSet.getParameter<double>("ptMax"),
         parameterSet.getParameter<double>("etaMin"),
         parameterSet.getParameter<double>("etaMax"),
         parameterSet.getParameter<double>("phiMin"),
         parameterSet.getParameter<double>("phiMax") );
 
 
   candBench_.setParameters(mode_);
   matchCandBench_.setParameters(mode_);
 }

void PFMETMonitor::setup ( void )

book histograms

Definition at line 140 of file PFMETMonitor.cc.

References Benchmark::book1D(), Benchmark::book2D(), candBench_, createMETSpecificHistos_, delta_ex_, delta_ex_VS_set_, delta_set_Over_set_VS_set_, delta_set_VS_set_, histogramBooked_, Benchmark::PhaseSpace::m, Benchmark::PhaseSpace::M, matchCandBench_, Benchmark::PhaseSpace::n, px_, CandidateBenchmark::setup(), MatchCandidateBenchmark::setup(), and sumEt_.

Referenced by PFMETDQMAnalyzer::beginJob(), and PFRootEventManager::readOptions().

                          {
   candBench_.setup();
   matchCandBench_.setup();
   
   if (createMETSpecificHistos_ && !histogramBooked_) {
 
     PhaseSpace pxPS       = PhaseSpace( 50, 0, 200);
     PhaseSpace dpxPS      = PhaseSpace( 50, -500, 500);    
     PhaseSpace setPS      = PhaseSpace( 50, 0.0, 3000);
     PhaseSpace dsetPS     = PhaseSpace( 50, -1000.0, 1000);
     PhaseSpace setOvsetPS = PhaseSpace( 100,0., 2.);
 
     px_  = book1D("px_", "px_;p_{X} (GeV)", pxPS.n, pxPS.m, pxPS.M);
 
     sumEt_ = book1D("sumEt_", "sumEt_;#sumE_{T}", setPS.n, setPS.m, setPS.M);
 
     delta_ex_ = book1D("delta_ex_", "#DeltaME_{X}", dpxPS.n, dpxPS.m, dpxPS.M);
     
     delta_ex_VS_set_ = book2D("delta_ex_VS_set_", ";SE_{T, true} (GeV);#DeltaE_{X}",
                   setPS.n, setPS.m, setPS.M, 
                   dpxPS.n, dpxPS.m, dpxPS.M );
     
     delta_set_VS_set_ = book2D("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("delta_set_Over_set_VS_set_", 
                     ";SE_{T, true} (GeV);#DeltaSE_{T}/SE_{T}",
                     setPS.n, setPS.m, setPS.M,
                     setOvsetPS.n, setOvsetPS.m, setOvsetPS.M );
     histogramBooked_ = true;
   }
 }

void PFMETMonitor::setup ( const edm::ParameterSet & parameterSet )

book histograms

Definition at line 72 of file PFMETMonitor.cc.

References Benchmark::book1D(), Benchmark::book2D(), candBench_, createMETSpecificHistos_, delta_ex_, delta_ex_VS_set_, delta_set_Over_set_VS_set_, delta_set_VS_set_, edm::ParameterSet::getParameter(), histogramBooked_, matchCandBench_, px_, CandidateBenchmark::setup(), MatchCandidateBenchmark::setup(), and sumEt_.

                                                              {
   candBench_.setup(parameterSet);
   matchCandBench_.setup(parameterSet);
   
   if (createMETSpecificHistos_ && !histogramBooked_) {
 
     edm::ParameterSet pxPS      = parameterSet.getParameter<edm::ParameterSet>("DeltaPxHistoParameter");
     edm::ParameterSet dpxPS      = parameterSet.getParameter<edm::ParameterSet>("DeltaPxHistoParameter");
     edm::ParameterSet dptPS      = parameterSet.getParameter<edm::ParameterSet>("DeltaPtHistoParameter");
     edm::ParameterSet setPS      = parameterSet.getParameter<edm::ParameterSet>("SumEtHistoParameter");
     edm::ParameterSet dsetPS     = parameterSet.getParameter<edm::ParameterSet>("DeltaSumEtHistoParameter");
     edm::ParameterSet setOvsetPS = parameterSet.getParameter<edm::ParameterSet>("DeltaSumEtOvSumEtHistoParameter");
     
     if (pxPS.getParameter<bool>("switchOn")) {
       px_  = book1D("px_", "px_;p_{X} (GeV)",
                      pxPS.getParameter<int32_t>("nBin"),
                      pxPS.getParameter<double>("xMin"),
              pxPS.getParameter<double>("xMax"));
     }
     if (setPS.getParameter<bool>("switchOn")) {
       sumEt_  = book1D("sumEt_", "sumEt_;#sumE_{T}",
                      setPS.getParameter<int32_t>("nBin"),
                      setPS.getParameter<double>("xMin"),
              setPS.getParameter<double>("xMax"));
     }
     if (dpxPS.getParameter<bool>("switchOn")) {
       delta_ex_  = book1D("delta_ex_", "#DeltaME_{X}",
                      dpxPS.getParameter<int32_t>("nBin"),
                      dpxPS.getParameter<double>("xMin"),
              dpxPS.getParameter<double>("xMax"));
     }
 
     if (dpxPS.getParameter<bool>("switchOn")) {
       delta_ex_VS_set_ = book2D("delta_ex_VS_set_", 
                 ";SE_{T, true} (GeV);#DeltaE_{X}",
                 setPS.getParameter<int32_t>("nBin"), 
                 setPS.getParameter<double>("xMin"), 
                 setPS.getParameter<double>("xMax"),                             
                 dptPS.getParameter<int32_t>("nBin"),
                 dptPS.getParameter<double>("xMin"), 
                 dptPS.getParameter<double>("xMax"));
     }
     if (dsetPS.getParameter<bool>("switchOn")) {
       delta_set_VS_set_ = book2D("delta_set_VS_set_", 
                  ";SE_{T, true} (GeV);#DeltaSE_{T}",
                  setPS.getParameter<int32_t>("nBin"), 
                  setPS.getParameter<double>("xMin"), 
                  setPS.getParameter<double>("xMax"),
                  dsetPS.getParameter<int32_t>("nBin"), 
                  dsetPS.getParameter<double>("xMin"), 
                  dsetPS.getParameter<double>("xMax"));
     }
     if (setOvsetPS.getParameter<bool>("switchOn")) {
       delta_set_Over_set_VS_set_ = book2D("delta_set_Over_set_VS_set_", 
                       ";SE_{T, true} (GeV);#DeltaSE_{T}/SE_{T}",
                       setPS.getParameter<int32_t>("nBin"), 
                       setPS.getParameter<double>("xMin"), 
                       setPS.getParameter<double>("xMax"),
                       setOvsetPS.getParameter<int32_t>("nBin"), 
                       setOvsetPS.getParameter<double>("xMin"), 
                       setOvsetPS.getParameter<double>("xMax"));
     }
     histogramBooked_ = true;
   }
 }