#include <GenericBenchmark.h>

Inheritance diagram for GenericBenchmark:

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Member Functions
template<typename C >
void	fill (const C RecoCollection, const C GenCollection, bool startFromGen=false, bool PlotAgainstReco=true, bool onlyTwoJets=false, double recPt_cut=-1., double minEta_cut=-1., double maxEta_cut=-1., double deltaR_cut=-1.)

	GenericBenchmark ()

void	setfile (TFile *file)

void	setup (DQMStore *DQM=nullptr, bool PlotAgainstReco_=true, float minDeltaEt=-100., float maxDeltaEt=50., float minDeltaPhi=-0.5, float maxDeltaPhi=0.5, bool doMetPlots=false)

void	write (std::string Filename)

virtual	~GenericBenchmark () noexcept(false)

Protected Attributes
PFBenchmarkAlgo *	algo_

DQMStore *	dbe_

Private Member Functions
bool	accepted (const reco::Candidate *particle, double ptCut, double minEtaCut, double maxEtaCut) const

void	fillHistos (const reco::Candidate genParticle, const reco::Candidate recParticle, double deltaR_cut, bool plotAgainstReco)

Private Attributes
bool	doMetPlots_

TFile *	file_

TH1F *	hDeltaEt

TH1F *	hDeltaEta

TH2F *	hDeltaEtavsEt

TH2F *	hDeltaEtavsEta

TH2F *	hDeltaEtOverEtvsDeltaR

TH2F *	hDeltaEtOverEtvsEt

TH2F *	hDeltaEtOverEtvsEta

TH2F *	hDeltaEtOverEtvsPhi

TH2F *	hDeltaEtvsDeltaR

TH2F *	hDeltaEtvsEt

TH2F *	hDeltaEtvsEta

TH2F *	hDeltaEtvsPhi

TH1F *	hDeltaEx

TH1F *	hDeltaEy

TH2F *	hDeltaMexvsSet

TH1F *	hDeltaPhi

TH2F *	hDeltaPhivsEt

TH2F *	hDeltaPhivsEta

TH1F *	hDeltaR

TH2F *	hDeltaRvsEt

TH2F *	hDeltaRvsEta

TH2F *	hDeltaSetOverSetvsSet

TH2F *	hDeltaSetvsSet

TH1F *	hEtaGen

TH1F *	hEtaSeen

TH1F *	hEtGen

TH1F *	hEtRec

TH2F *	hEtRecOverTrueEtvsTrueEt

TH2F *	hEtRecvsEt

TH1F *	hEtSeen

TH2F *	hEtvsEtaGen

TH2F *	hEtvsEtaSeen

TH2F *	hEtvsPhiGen

TH2F *	hEtvsPhiSeen

TH1F *	hExRec

TH1F *	hEyRec

TH1F *	hNGen

TH1F *	hNRec

TH1F *	hPhiGen

TH1F *	hPhiRec

TH1F *	hPhiSeen

TH2F *	hRecSetOverTrueSetvsTrueSet

TH2F *	hRecSetvsTrueSet

TH1F *	hSumEt

TH2F *	hTrueMexvsTrueSet

TH1F *	hTrueSumEt

BenchmarkTree *	tree_

Detailed Description

Definition at line 21 of file GenericBenchmark.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore GenericBenchmark::DQMStore

Definition at line 23 of file GenericBenchmark.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement GenericBenchmark::MonitorElement

Definition at line 24 of file GenericBenchmark.h.

Constructor & Destructor Documentation

◆ GenericBenchmark()

GenericBenchmark::GenericBenchmark ( )

Definition at line 33 of file GenericBenchmark.cc.

33 {}

◆ ~GenericBenchmark()

GenericBenchmark::~GenericBenchmark ( )

virtualnoexcept

Definition at line 35 of file GenericBenchmark.cc.

35 {}

Member Function Documentation

◆ accepted()

bool GenericBenchmark::accepted	(	const reco::Candidate *	particle,
		double	ptCut,
		double	minEtaCut,
		double	maxEtaCut
	)		const

private

Definition at line 238 of file GenericBenchmark.cc.

                                                         {
   //skip reconstructed PFJets with p_t < recPt_cut
   if (particle->pt() < ptCut and ptCut != -1.)
     return false;
  
   if (fabs(particle->eta()) > maxEtaCut and maxEtaCut > 0)
     return false;
   if (fabs(particle->eta()) < minEtaCut and minEtaCut > 0)
     return false;
  
   //accepted!
   return true;
 }

References reco::Candidate::eta(), reco::Candidate::pt(), and jetfilter_cfi::ptCut.

Referenced by fill().

◆ fill()

template<typename C >

void GenericBenchmark::fill	(	const C *	RecoCollection,
		const C *	GenCollection,
		bool	startFromGen = `false`,
		bool	PlotAgainstReco = `true`,
		bool	onlyTwoJets = `false`,
		double	recPt_cut = `-1.`,
		double	minEta_cut = `-1.`,
		double	maxEta_cut = `-1.`,
		double	deltaR_cut = `-1.`
	)

Definition at line 129 of file GenericBenchmark.h.

                                                {
   //if (doMetPlots_)
   //{
   //  const reco::MET* met1=static_cast<const reco::MET*>(&((*RecoCollection)[0]));
   //  if (met1!=NULL) std::cout << "FL: met1.sumEt() = " << (*met1).sumEt() << std::endl;
   //}
  
   // loop over reco particles
  
   if (!startFromGen) {
     int nRec = 0;
     for (unsigned int i = 0; i < RecoCollection->size(); i++) {
       // generate histograms comparing the reco and truth candidate (truth = closest in delta-R)
       const reco::Candidate *particle = &(*RecoCollection)[i];
  
       assert(particle != nullptr);
       if (!accepted(particle, recPt_cut, minEta_cut, maxEta_cut))
         continue;
  
       // Count the number of jets with a larger energy
       if (onlyTwoJets) {
         unsigned highJets = 0;
         for (unsigned j = 0; j < RecoCollection->size(); j++) {
           const reco::Candidate *otherParticle = &(*RecoCollection)[j];
           if (j != i && otherParticle->pt() > particle->pt())
             highJets++;
         }
         if (highJets > 1)
           continue;
       }
       nRec++;
  
       const reco::Candidate *gen_particle = algo_->matchByDeltaR(particle, GenCollection);
       if (gen_particle == nullptr)
         continue;
  
       // fill histograms
       fillHistos(gen_particle, particle, deltaR_cut, PlotAgainstReco);
     }
  
     hNRec->Fill(nRec);
   }
  
   // loop over gen particles
  
   //   std::cout<<"Reco size = "<<RecoCollection->size()<<", ";
   //   std::cout<<"Gen size = "<<GenCollection->size()<<std::endl;
  
   int nGen = 0;
   for (unsigned int i = 0; i < GenCollection->size(); i++) {
     const reco::Candidate *gen_particle = &(*GenCollection)[i];
  
     if (!accepted(gen_particle, recPt_cut, minEta_cut, maxEta_cut)) {
       continue;
     }
  
     hEtaGen->Fill(gen_particle->eta());
     hPhiGen->Fill(gen_particle->phi());
     hEtGen->Fill(gen_particle->et());
     hEtvsEtaGen->Fill(gen_particle->eta(), gen_particle->et());
     hEtvsPhiGen->Fill(gen_particle->phi(), gen_particle->et());
  
     const reco::Candidate *rec_particle = algo_->matchByDeltaR(gen_particle, RecoCollection);
     nGen++;
     if (!rec_particle)
       continue;  // no match
     // must make a cut on delta R - so let's do the cut
  
     double deltaR = algo_->deltaR(rec_particle, gen_particle);
     if (deltaR > deltaR_cut && deltaR_cut != -1.)
       continue;
  
     hEtaSeen->Fill(gen_particle->eta());
     hPhiSeen->Fill(gen_particle->phi());
     hEtSeen->Fill(gen_particle->et());
     hEtvsEtaSeen->Fill(gen_particle->eta(), gen_particle->et());
     hEtvsPhiSeen->Fill(gen_particle->phi(), gen_particle->et());
  
     hPhiRec->Fill(rec_particle->phi());
     hEtRec->Fill(rec_particle->et());
     hExRec->Fill(rec_particle->px());
     hEyRec->Fill(rec_particle->py());
  
     hEtRecvsEt->Fill(gen_particle->et(), rec_particle->et());
     if (gen_particle->et() != 0.0)
       hEtRecOverTrueEtvsTrueEt->Fill(gen_particle->et(), rec_particle->et() / gen_particle->et());
  
     if (startFromGen)
       fillHistos(gen_particle, rec_particle, deltaR_cut, PlotAgainstReco);
   }
   hNGen->Fill(nGen);
 }

References accepted(), algo_, cms::cuda::assert(), PFBenchmarkAlgo::deltaR(), PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::Candidate::et(), reco::Candidate::eta(), fillHistos(), hEtaGen, hEtaSeen, hEtGen, hEtRec, hEtRecOverTrueEtvsTrueEt, hEtRecvsEt, hEtSeen, hEtvsEtaGen, hEtvsEtaSeen, hEtvsPhiGen, hEtvsPhiSeen, hExRec, hEyRec, hNGen, hNRec, hPhiGen, hPhiRec, hPhiSeen, mps_fire::i, dqmiolumiharvest::j, PFBenchmarkAlgo::matchByDeltaR(), onlyTwoJets, reco::Candidate::phi(), reco::Candidate::pt(), reco::Candidate::px(), reco::Candidate::py(), and EgammaObjectsElectrons_cfi::RecoCollection.

◆ fillHistos()

void GenericBenchmark::fillHistos	(	const reco::Candidate *	genParticle,
		const reco::Candidate *	recParticle,
		double	deltaR_cut,
		bool	plotAgainstReco
	)

private

Definition at line 255 of file GenericBenchmark.cc.

                                                         {
   // get the quantities to place on the denominator and/or divide by
   double et = genParticle->et();
   double eta = genParticle->eta();
   double phi = genParticle->phi();
   //std::cout << "FL : et = " << et << std::endl;
   //std::cout << "FL : eta = " << eta << std::endl;
   //std::cout << "FL : phi = " << phi << std::endl;
   //std::cout << "FL : rec et = " << recParticle->et() << std::endl;
   //std::cout << "FL : rec eta = " << recParticle->eta() << std::endl;
   //std::cout << "FL : rec phi = " <<recParticle-> phi() << std::endl;
  
   if (plotAgainstReco) {
     et = recParticle->et();
     eta = recParticle->eta();
     phi = recParticle->phi();
   }
  
   // get the delta quantities
   double deltaEt = algo_->deltaEt(recParticle, genParticle);
   double deltaR = algo_->deltaR(recParticle, genParticle);
   double deltaEta = algo_->deltaEta(recParticle, genParticle);
   double deltaPhi = algo_->deltaPhi(recParticle, genParticle);
  
   //std::cout << "FL :deltaR_cut = " << deltaR_cut << std::endl;
   //std::cout << "FL :deltaR = " << deltaR << std::endl;
  
   if (deltaR > deltaR_cut && deltaR_cut != -1.)
     return;
  
   hDeltaEt->Fill(deltaEt);
   hDeltaEx->Fill(recParticle->px() - genParticle->px());
   hDeltaEy->Fill(recParticle->py() - genParticle->py());
   hDeltaEtvsEt->Fill(et, deltaEt);
   hDeltaEtOverEtvsEt->Fill(et, deltaEt / et);
   hDeltaEtvsEta->Fill(eta, deltaEt);
   hDeltaEtOverEtvsEta->Fill(eta, deltaEt / et);
   hDeltaEtvsPhi->Fill(phi, deltaEt);
   hDeltaEtOverEtvsPhi->Fill(phi, deltaEt / et);
   hDeltaEtvsDeltaR->Fill(deltaR, deltaEt);
   hDeltaEtOverEtvsDeltaR->Fill(deltaR, deltaEt / et);
  
   hDeltaEta->Fill(deltaEta);
   hDeltaEtavsEt->Fill(et, deltaEta);
   hDeltaEtavsEta->Fill(eta, deltaEta);
  
   hDeltaPhi->Fill(deltaPhi);
   hDeltaPhivsEt->Fill(et, deltaPhi);
   hDeltaPhivsEta->Fill(eta, deltaPhi);
  
   hDeltaR->Fill(deltaR);
   hDeltaRvsEt->Fill(et, deltaR);
   hDeltaRvsEta->Fill(eta, deltaR);
  
   BenchmarkTreeEntry entry;
   entry.deltaEt = deltaEt;
   entry.deltaEta = deltaEta;
   entry.et = et;
   entry.eta = eta;
  
   if (doMetPlots_) {
     const reco::MET* met1 = static_cast<const reco::MET*>(genParticle);
     const reco::MET* met2 = static_cast<const reco::MET*>(recParticle);
     if (met1 != nullptr && met2 != nullptr) {
       //std::cout << "FL: met1.sumEt() = " << (*met1).sumEt() << std::endl;
       hTrueSumEt->Fill((*met1).sumEt());
       hSumEt->Fill((*met2).sumEt());
       hDeltaSetvsSet->Fill((*met1).sumEt(), (*met2).sumEt() - (*met1).sumEt());
       hDeltaMexvsSet->Fill((*met1).sumEt(), recParticle->px() - genParticle->px());
       hDeltaMexvsSet->Fill((*met1).sumEt(), recParticle->py() - genParticle->py());
       if ((*met1).sumEt() > 0.01)
         hDeltaSetOverSetvsSet->Fill((*met1).sumEt(), ((*met2).sumEt() - (*met1).sumEt()) / (*met1).sumEt());
       hRecSetvsTrueSet->Fill((*met1).sumEt(), (*met2).sumEt());
       hRecSetOverTrueSetvsTrueSet->Fill((*met1).sumEt(), (*met2).sumEt() / ((*met1).sumEt()));
       hTrueMexvsTrueSet->Fill((*met1).sumEt(), (*met1).px());
       hTrueMexvsTrueSet->Fill((*met1).sumEt(), (*met1).py());
     } else {
       std::cout << "Warning : reco::MET* == NULL" << std::endl;
     }
   }
  
   //     tree_->Fill(entry);
 }

References gather_cfg::cout, spr::deltaEta, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, mps_splice::entry, EgHLTOffHistBins_cfi::et, reco::Candidate::et(), PVValHelper::eta, reco::Candidate::eta(), reco::Candidate::phi(), plotAgainstReco, reco::Candidate::px(), and reco::Candidate::py().

Referenced by fill().

◆ setfile()

void GenericBenchmark::setfile ( TFile * file )

Definition at line 347 of file GenericBenchmark.cc.

347 { file_ = file; }

References FrontierConditions_GlobalTag_cff::file.

◆ setup()

void GenericBenchmark::setup	(	DQMStore *	DQM = `nullptr`,
		bool	PlotAgainstReco_ = `true`,
		float	minDeltaEt = `-100.`,
		float	maxDeltaEt = `50.`,
		float	minDeltaPhi = `-0.5`,
		float	maxDeltaPhi = `0.5`,
		bool	doMetPlots = `false`
	)

Definition at line 37 of file GenericBenchmark.cc.

                                               {
   //std::cout << "minDeltaPhi = " << minDeltaPhi << std::endl;
  
   // CMSSW_2_X_X
   // use bare Root if no DQM (FWLite applications)
   //if (!DQM)
   //{
   //  file_ = new TFile("pfmetBenchmark.root", "recreate");
   //  cout << "Info: DQM is not available to provide data storage service. Using TFile to save histograms. "<<endl;
   //}
   // Book Histograms
  
   //std::cout << "FL : pwd = ";
   //gDirectory->pwd();
   //std::cout << std::endl;
  
   int nbinsEt = 1000;
   float minEt = 0;
   float maxEt = 1000;
  
   //float minDeltaEt = -100;
   //float maxDeltaEt = 50;
  
   int nbinsEta = 200;
   float minEta = -5;
   float maxEta = 5;
  
   int nbinsDeltaEta = 1000;
   float minDeltaEta = -0.5;
   float maxDeltaEta = 0.5;
  
   int nbinsDeltaPhi = 1000;
   //float minDeltaPhi = -0.5;
   //float maxDeltaPhi = 0.5;
  
   // delta et quantities
   BOOK1D(DeltaEt, "#DeltaE_{T}", nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK1D(DeltaEx, "#DeltaE_{X}", nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK1D(DeltaEy, "#DeltaE_{Y}", nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK2D(DeltaEtvsEt, "#DeltaE_{T} vs E_{T}", nbinsEt, minEt, maxEt, nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK2D(DeltaEtOverEtvsEt, "#DeltaE_{T}/E_{T} vsE_{T}", nbinsEt, minEt, maxEt, nbinsEt, -1, 1);
   BOOK2D(DeltaEtvsEta, "#DeltaE_{T} vs #eta", nbinsEta, minEta, maxEta, nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK2D(DeltaEtOverEtvsEta, "#DeltaE_{T}/E_{T} vs #eta", nbinsEta, minEta, maxEta, 100, -1, 1);
   BOOK2D(DeltaEtvsPhi, "#DeltaE_{T} vs #phi", 200, -M_PI, M_PI, nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK2D(DeltaEtOverEtvsPhi, "#DeltaE_{T}/E_{T} vs #Phi", 200, -M_PI, M_PI, 100, -1, 1);
   BOOK2D(DeltaEtvsDeltaR, "#DeltaE_{T} vs #DeltaR", 100, 0, 1, nbinsEt, minDeltaEt, maxDeltaEt);
   BOOK2D(DeltaEtOverEtvsDeltaR, "#DeltaE_{T}/E_{T} vs #DeltaR", 100, 0, 1, 100, -1, 1);
  
   // delta eta quantities
   BOOK1D(DeltaEta, "#Delta#eta", nbinsDeltaEta, minDeltaEta, maxDeltaEta);
   BOOK2D(DeltaEtavsEt, "#Delta#eta vs E_{T}", nbinsEt, minEt, maxEt, nbinsDeltaEta, minDeltaEta, maxDeltaEta);
   BOOK2D(DeltaEtavsEta, "#Delta#eta vs #eta", nbinsEta, minEta, maxEta, nbinsDeltaEta, minDeltaEta, maxDeltaEta);
  
   // delta phi quantities
   BOOK1D(DeltaPhi, "#Delta#phi", nbinsDeltaPhi, minDeltaPhi, maxDeltaPhi);
   BOOK2D(DeltaPhivsEt, "#Delta#phi vs E_{T}", nbinsEt, minEt, maxEt, nbinsDeltaPhi, minDeltaPhi, maxDeltaPhi);
   BOOK2D(DeltaPhivsEta, "#Delta#phi vs #eta", nbinsEta, minEta, maxEta, nbinsDeltaPhi, minDeltaPhi, maxDeltaPhi);
  
   // delta R quantities
   BOOK1D(DeltaR, "#DeltaR", 100, 0, 1);
   BOOK2D(DeltaRvsEt, "#DeltaR vs E_{T}", nbinsEt, minEt, maxEt, 100, 0, 1);
   BOOK2D(DeltaRvsEta, "#DeltaR vs #eta", nbinsEta, minEta, maxEta, 100, 0, 1);
  
   BOOK1D(NRec, "Number of reconstructed objects", 20, 0, 20);
  
   // seen and gen distributions, for efficiency computation
   BOOK1D(EtaSeen, "seen #eta", 100, -5, 5);
   BOOK1D(PhiSeen, "seen #phi", 100, -3.5, 3.5);
   BOOK1D(EtSeen, "seen E_{T}", nbinsEt, minEt, maxEt);
   BOOK2D(EtvsEtaSeen, "seen E_{T} vs eta", 100, -5, 5, 200, 0, 200);
   BOOK2D(EtvsPhiSeen, "seen E_{T} vs seen #phi", 100, -3.5, 3.5, 200, 0, 200);
  
   BOOK1D(PhiRec, "Rec #phi", 100, -3.5, 3.5);
   BOOK1D(EtRec, "Rec E_{T}", nbinsEt, minEt, maxEt);
   BOOK1D(ExRec, "Rec E_{X}", nbinsEt, -maxEt, maxEt);
   BOOK1D(EyRec, "Rec E_{Y}", nbinsEt, -maxEt, maxEt);
  
   BOOK2D(EtRecvsEt, "Rec E_{T} vs E_{T}", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
   BOOK2D(EtRecOverTrueEtvsTrueEt, "Rec E_{T} / E_{T} vs E_{T}", nbinsEt, minEt, maxEt, 1000, 0., 100.);
  
   BOOK1D(EtaGen, "generated #eta", 100, -5, 5);
   BOOK1D(PhiGen, "generated #phi", 100, -3.5, 3.5);
   BOOK1D(EtGen, "generated E_{T}", nbinsEt, minEt, maxEt);
   BOOK2D(EtvsEtaGen, "generated E_{T} vs generated #eta", 100, -5, 5, 200, 0, 200);
   BOOK2D(EtvsPhiGen, "generated E_{T} vs generated #phi", 100, -3.5, 3.5, 200, 0, 200);
  
   BOOK1D(NGen, "Number of generated objects", 20, 0, 20);
  
   if (doMetPlots) {
     BOOK1D(SumEt, "SumEt", 1000, 0., 3000.);
     BOOK1D(TrueSumEt, "TrueSumEt", 1000, 0., 3000.);
     BOOK2D(DeltaSetvsSet, "#DeltaSEt vs trueSEt", 3000, 0., 3000., 1000, -1000., 1000.);
     BOOK2D(DeltaMexvsSet, "#DeltaMEX vs trueSEt", 3000, 0., 3000., 1000, -400., 400.);
     BOOK2D(DeltaSetOverSetvsSet, "#DeltaSetOverSet vs trueSet", 3000, 0., 3000., 1000, -1., 1.);
     BOOK2D(RecSetvsTrueSet, "Set vs trueSet", 3000, 0., 3000., 3000, 0., 3000.);
     BOOK2D(RecSetOverTrueSetvsTrueSet, "Set/trueSet vs trueSet", 3000, 0., 3000., 500, 0., 2.);
     BOOK2D(TrueMexvsTrueSet, "trueMex vs trueSet", 3000, 0., 3000., nbinsEt, -maxEt, maxEt);
   }
   // number of truth particles found within given cone radius of reco
   //BOOK2D(NumInConeVsConeSize,NumInConeVsConeSize,100,0,1,25,0,25);
  
   // Set Axis Titles
  
   // delta et quantities
   SETAXES(DeltaEt, "#DeltaE_{T} [GeV]", "");
   SETAXES(DeltaEx, "#DeltaE_{X} [GeV]", "");
   SETAXES(DeltaEy, "#DeltaE_{Y} [GeV]", "");
   SETAXES(DeltaEtvsEt, ET, "#DeltaE_{T} [GeV]");
   SETAXES(DeltaEtOverEtvsEt, ET, "#DeltaE_{T}/E_{T}");
   SETAXES(DeltaEtvsEta, ETA, "#DeltaE_{T} [GeV]");
   SETAXES(DeltaEtOverEtvsEta, ETA, "#DeltaE_{T}/E_{T}");
   SETAXES(DeltaEtvsPhi, PHI, "#DeltaE_{T} [GeV]");
   SETAXES(DeltaEtOverEtvsPhi, PHI, "#DeltaE_{T}/E_{T}");
   SETAXES(DeltaEtvsDeltaR, "#DeltaR", "#DeltaE_{T} [GeV]");
   SETAXES(DeltaEtOverEtvsDeltaR, "#DeltaR", "#DeltaE_{T}/E_{T}");
  
   // delta eta quantities
   SETAXES(DeltaEta, "#Delta#eta", "Events");
   SETAXES(DeltaEtavsEt, ET, "#Delta#eta");
   SETAXES(DeltaEtavsEta, ETA, "#Delta#eta");
  
   // delta phi quantities
   SETAXES(DeltaPhi, "#Delta#phi [rad]", "Events");
   SETAXES(DeltaPhivsEt, ET, "#Delta#phi [rad]");
   SETAXES(DeltaPhivsEta, ETA, "#Delta#phi [rad]");
  
   // delta R quantities
   SETAXES(DeltaR, "#DeltaR", "Events");
   SETAXES(DeltaRvsEt, ET, "#DeltaR");
   SETAXES(DeltaRvsEta, ETA, "#DeltaR");
  
   SETAXES(NRec, "Number of Rec Objects", "");
  
   SETAXES(EtaSeen, "seen #eta", "");
   SETAXES(PhiSeen, "seen #phi [rad]", "");
   SETAXES(EtSeen, "seen E_{T} [GeV]", "");
   SETAXES(EtvsEtaSeen, "seen #eta", "seen E_{T}");
   SETAXES(EtvsPhiSeen, "seen #phi [rad]", "seen E_{T}");
  
   SETAXES(PhiRec, "#phi [rad]", "");
   SETAXES(EtRec, "E_{T} [GeV]", "");
   SETAXES(ExRec, "E_{X} [GeV]", "");
   SETAXES(EyRec, "E_{Y} [GeV]", "");
   SETAXES(EtRecvsEt, ET, "Rec E_{T} [GeV]");
   SETAXES(EtRecOverTrueEtvsTrueEt, ET, "Rec E_{T} / E_{T} [GeV]");
  
   SETAXES(EtaGen, "generated #eta", "");
   SETAXES(PhiGen, "generated #phi [rad]", "");
   SETAXES(EtGen, "generated E_{T} [GeV]", "");
   SETAXES(EtvsPhiGen, "generated #phi [rad]", "generated E_{T} [GeV]");
   SETAXES(EtvsEtaGen, "generated #eta", "generated E_{T} [GeV]");
  
   SETAXES(NGen, "Number of Gen Objects", "");
  
   if (doMetPlots) {
     SETAXES(SumEt, "SumEt [GeV]", "");
     SETAXES(TrueSumEt, "TrueSumEt [GeV]", "");
     SETAXES(DeltaSetvsSet, "TrueSumEt", "#DeltaSumEt [GeV]");
     SETAXES(DeltaMexvsSet, "TrueSumEt", "#DeltaMEX [GeV]");
     SETAXES(DeltaSetOverSetvsSet, "TrueSumEt", "#DeltaSumEt/trueSumEt");
     SETAXES(RecSetvsTrueSet, "TrueSumEt", "SumEt");
     SETAXES(RecSetOverTrueSetvsTrueSet, "TrueSumEt", "SumEt/trueSumEt");
     SETAXES(TrueMexvsTrueSet, "TrueSumEt", "TrueMEX");
   }
  
   TDirectory* oldpwd = gDirectory;
  
   TIter next(gROOT->GetListOfFiles());
  
   const bool debug = false;
  
   while (TFile* file = (TFile*)next()) {
     if (debug)
       cout << "file " << file->GetName() << endl;
   }
   if (DQM) {
     cout << "DQM subdir" << endl;
     cout << DQM->pwd().c_str() << endl;
  
     DQM->cd(DQM->pwd());
   }
  
   if (debug) {
     cout << "current dir" << endl;
     gDirectory->pwd();
   }
  
   oldpwd->cd();
   //gDirectory->pwd();
  
   doMetPlots_ = doMetPlots;
  
   //   tree_ = new BenchmarkTree("genericBenchmark", "Generic Benchmark TTree");
 }

References BOOK1D, BOOK2D, gather_cfg::cout, debug, HLT_FULL_cff::DeltaEta, benchmark_cfg::doMetPlots, ET, ETA, FrontierConditions_GlobalTag_cff::file, M_PI, benchmark_cfg::maxDeltaEt, CommPDSkim_cfg::maxDeltaEta, CommPDSkim_cfg::maxDeltaPhi, heavyionUCCDQM_cfi::maxEt, maxEta, benchmark_cfg::minDeltaEt, HLTInclusiveVBFSource_cfi::minDeltaEta, VBFGenJetFilter_cfi::minDeltaPhi, EgHLTOffEleSelection_cfi::minEt, EgHLTOffEleSelection_cfi::minEta, L1MuGMTScales_cfi::nbinsDeltaEta, L1MuGMTScales_cfi::nbinsDeltaPhi, GetRecoTauVFromDQM_MC_cff::next, PHI, and SETAXES.

◆ write()

void GenericBenchmark::write ( std::string Filename )

Definition at line 342 of file GenericBenchmark.cc.

                                                {
   if (!Filename.empty() && file_)
     file_->Write(Filename.c_str());
 }

Member Data Documentation

◆ algo_

PFBenchmarkAlgo* GenericBenchmark::algo_

protected

Definition at line 125 of file GenericBenchmark.h.

Referenced by fill().

◆ dbe_

DQMStore* GenericBenchmark::dbe_

protected

Definition at line 124 of file GenericBenchmark.h.

◆ doMetPlots_

bool GenericBenchmark::doMetPlots_

private

Definition at line 121 of file GenericBenchmark.h.

◆ file_

TFile* GenericBenchmark::file_

private

Definition at line 60 of file GenericBenchmark.h.

◆ hDeltaEt

TH1F* GenericBenchmark::hDeltaEt

private

Definition at line 62 of file GenericBenchmark.h.

◆ hDeltaEta

TH1F* GenericBenchmark::hDeltaEta

private

Definition at line 77 of file GenericBenchmark.h.

◆ hDeltaEtavsEt

TH2F* GenericBenchmark::hDeltaEtavsEt

private

Definition at line 78 of file GenericBenchmark.h.

◆ hDeltaEtavsEta

TH2F* GenericBenchmark::hDeltaEtavsEta

private

Definition at line 79 of file GenericBenchmark.h.

◆ hDeltaEtOverEtvsDeltaR

TH2F* GenericBenchmark::hDeltaEtOverEtvsDeltaR

private

Definition at line 72 of file GenericBenchmark.h.

◆ hDeltaEtOverEtvsEt

TH2F* GenericBenchmark::hDeltaEtOverEtvsEt

private

Definition at line 66 of file GenericBenchmark.h.

◆ hDeltaEtOverEtvsEta

TH2F* GenericBenchmark::hDeltaEtOverEtvsEta

private

Definition at line 68 of file GenericBenchmark.h.

◆ hDeltaEtOverEtvsPhi

TH2F* GenericBenchmark::hDeltaEtOverEtvsPhi

private

Definition at line 70 of file GenericBenchmark.h.

◆ hDeltaEtvsDeltaR

TH2F* GenericBenchmark::hDeltaEtvsDeltaR

private

Definition at line 71 of file GenericBenchmark.h.

◆ hDeltaEtvsEt

TH2F* GenericBenchmark::hDeltaEtvsEt

private

Definition at line 65 of file GenericBenchmark.h.

◆ hDeltaEtvsEta

TH2F* GenericBenchmark::hDeltaEtvsEta

private

Definition at line 67 of file GenericBenchmark.h.

◆ hDeltaEtvsPhi

TH2F* GenericBenchmark::hDeltaEtvsPhi

private

Definition at line 69 of file GenericBenchmark.h.

◆ hDeltaEx

TH1F* GenericBenchmark::hDeltaEx

private

Definition at line 63 of file GenericBenchmark.h.

◆ hDeltaEy

TH1F* GenericBenchmark::hDeltaEy

private

Definition at line 64 of file GenericBenchmark.h.

◆ hDeltaMexvsSet

TH2F* GenericBenchmark::hDeltaMexvsSet

private

Definition at line 113 of file GenericBenchmark.h.

◆ hDeltaPhi

TH1F* GenericBenchmark::hDeltaPhi

private

Definition at line 81 of file GenericBenchmark.h.

◆ hDeltaPhivsEt

TH2F* GenericBenchmark::hDeltaPhivsEt

private

Definition at line 82 of file GenericBenchmark.h.

◆ hDeltaPhivsEta

TH2F* GenericBenchmark::hDeltaPhivsEta

private

Definition at line 83 of file GenericBenchmark.h.

◆ hDeltaR

TH1F* GenericBenchmark::hDeltaR

private

Definition at line 85 of file GenericBenchmark.h.

◆ hDeltaRvsEt

TH2F* GenericBenchmark::hDeltaRvsEt

private

Definition at line 86 of file GenericBenchmark.h.

◆ hDeltaRvsEta

TH2F* GenericBenchmark::hDeltaRvsEta

private

Definition at line 87 of file GenericBenchmark.h.

◆ hDeltaSetOverSetvsSet

TH2F* GenericBenchmark::hDeltaSetOverSetvsSet

private

Definition at line 114 of file GenericBenchmark.h.

◆ hDeltaSetvsSet

TH2F* GenericBenchmark::hDeltaSetvsSet

private

Definition at line 112 of file GenericBenchmark.h.

◆ hEtaGen

TH1F* GenericBenchmark::hEtaGen

private

Definition at line 92 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtaSeen

TH1F* GenericBenchmark::hEtaSeen

private

Definition at line 100 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtGen

TH1F* GenericBenchmark::hEtGen

private

Definition at line 91 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtRec

TH1F* GenericBenchmark::hEtRec

private

Definition at line 105 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtRecOverTrueEtvsTrueEt

TH2F* GenericBenchmark::hEtRecOverTrueEtvsTrueEt

private

Definition at line 75 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtRecvsEt

TH2F* GenericBenchmark::hEtRecvsEt

private

Definition at line 74 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtSeen

TH1F* GenericBenchmark::hEtSeen

private

Definition at line 99 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtvsEtaGen

TH2F* GenericBenchmark::hEtvsEtaGen

private

Definition at line 93 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtvsEtaSeen

TH2F* GenericBenchmark::hEtvsEtaSeen

private

Definition at line 102 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtvsPhiGen

TH2F* GenericBenchmark::hEtvsPhiGen

private

Definition at line 94 of file GenericBenchmark.h.

Referenced by fill().

◆ hEtvsPhiSeen

TH2F* GenericBenchmark::hEtvsPhiSeen

private

Definition at line 103 of file GenericBenchmark.h.

Referenced by fill().

◆ hExRec

TH1F* GenericBenchmark::hExRec

private

Definition at line 106 of file GenericBenchmark.h.

Referenced by fill().

◆ hEyRec

TH1F* GenericBenchmark::hEyRec

private

Definition at line 107 of file GenericBenchmark.h.

Referenced by fill().

◆ hNGen

TH1F* GenericBenchmark::hNGen

private

Definition at line 97 of file GenericBenchmark.h.

Referenced by fill().

◆ hNRec

TH1F* GenericBenchmark::hNRec

private

Definition at line 89 of file GenericBenchmark.h.

Referenced by fill().

◆ hPhiGen

TH1F* GenericBenchmark::hPhiGen

private

Definition at line 95 of file GenericBenchmark.h.

Referenced by fill().

◆ hPhiRec

TH1F* GenericBenchmark::hPhiRec

private

Definition at line 108 of file GenericBenchmark.h.

Referenced by fill().

◆ hPhiSeen

TH1F* GenericBenchmark::hPhiSeen

private

Definition at line 101 of file GenericBenchmark.h.

Referenced by fill().

◆ hRecSetOverTrueSetvsTrueSet

TH2F* GenericBenchmark::hRecSetOverTrueSetvsTrueSet

private

Definition at line 116 of file GenericBenchmark.h.

◆ hRecSetvsTrueSet

TH2F* GenericBenchmark::hRecSetvsTrueSet

private

Definition at line 115 of file GenericBenchmark.h.

◆ hSumEt

TH1F* GenericBenchmark::hSumEt

private

Definition at line 110 of file GenericBenchmark.h.

◆ hTrueMexvsTrueSet

TH2F* GenericBenchmark::hTrueMexvsTrueSet

private

Definition at line 117 of file GenericBenchmark.h.

◆ hTrueSumEt

TH1F* GenericBenchmark::hTrueSumEt

private

Definition at line 111 of file GenericBenchmark.h.

◆ tree_

BenchmarkTree* GenericBenchmark::tree_

private

Definition at line 119 of file GenericBenchmark.h.

Public Types

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DQMStore

◆ MonitorElement

Constructor & Destructor Documentation

◆ GenericBenchmark()

◆ ~GenericBenchmark()

Member Function Documentation

◆ accepted()

◆ fill()

◆ fillHistos()

◆ setfile()

◆ setup()

◆ write()

Member Data Documentation

◆ algo_

◆ dbe_

◆ doMetPlots_

◆ file_

◆ hDeltaEt

◆ hDeltaEta

◆ hDeltaEtavsEt

◆ hDeltaEtavsEta

◆ hDeltaEtOverEtvsDeltaR

◆ hDeltaEtOverEtvsEt

◆ hDeltaEtOverEtvsEta

◆ hDeltaEtOverEtvsPhi

◆ hDeltaEtvsDeltaR

◆ hDeltaEtvsEt

◆ hDeltaEtvsEta

◆ hDeltaEtvsPhi

◆ hDeltaEx

◆ hDeltaEy

◆ hDeltaMexvsSet

◆ hDeltaPhi

◆ hDeltaPhivsEt

◆ hDeltaPhivsEta

◆ hDeltaR

◆ hDeltaRvsEt

◆ hDeltaRvsEta

◆ hDeltaSetOverSetvsSet

◆ hDeltaSetvsSet

◆ hEtaGen

◆ hEtaSeen

◆ hEtGen

◆ hEtRec

◆ hEtRecOverTrueEtvsTrueEt

◆ hEtRecvsEt

◆ hEtSeen

◆ hEtvsEtaGen

◆ hEtvsEtaSeen

◆ hEtvsPhiGen

◆ hEtvsPhiSeen

◆ hExRec

◆ hEyRec

◆ hNGen

◆ hNRec

◆ hPhiGen

◆ hPhiRec

◆ hPhiSeen

◆ hRecSetOverTrueSetvsTrueSet

◆ hRecSetvsTrueSet

◆ hSumEt

◆ hTrueMexvsTrueSet

◆ hTrueSumEt

◆ tree_