GenericBenchmark Class Reference

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

{}

~GenericBenchmark()

GenericBenchmark::~GenericBenchmark ( )

virtualnoexcept

Definition at line 35 of file GenericBenchmark.cc.

{}

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.

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

Referenced by fill().

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

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.

References accepted(), algo_, cms::cuda::assert(), PFBenchmarkAlgo::deltaR(), PbPb_ZMuSkimMuonDPG_cff::deltaR, reco::Candidate::et(), reco::Candidate::eta(), fillHistos(), RecoTauValidationMiniAOD_cfi::GenCollection, 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(), PFJetDQMAnalyzer_cfi::onlyTwoJets, reco::Candidate::phi(), reco::Candidate::pt(), reco::Candidate::px(), reco::Candidate::py(), and EgammaObjectsElectrons_cfi::RecoCollection.

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

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.

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(), hDeltaR::Fill(), reco::Candidate::phi(), reco::Candidate::px(), and reco::Candidate::py().

Referenced by fill().

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

setfile()

void GenericBenchmark::setfile

(

TFile *

file

)

Definition at line 347 of file GenericBenchmark.cc.

References geometryDiff::file.

{ file_ = 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.

References BOOK1D, BOOK2D, gather_cfg::cout, debug, HLT_2024v12_cff::DeltaEta, caloJetBenchmarkGeneric_cfi::doMetPlots, ET, ETA, geometryDiff::file, M_PI, caloJetBenchmarkGeneric_cfi::maxDeltaEt, CommPDSkim_cfg::maxDeltaEta, CommPDSkim_cfg::maxDeltaPhi, heavyionUCCDQM_cfi::maxEt, razorScouting_cff::maxEta, caloJetBenchmarkGeneric_cfi::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.

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

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.