GenericBenchmark Class Reference

#include <GenericBenchmark.h>

Inheritance diagram for GenericBenchmark:

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=0, 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 ()(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 24 of file GenericBenchmark.h.

Constructor & Destructor Documentation

GenericBenchmark::GenericBenchmark

(

)

Definition at line 37 of file GenericBenchmark.cc.

{}

GenericBenchmark::~GenericBenchmark ( )

virtual

Definition at line 39 of file GenericBenchmark.cc.

{}

Member Function Documentation

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

private

Definition at line 288 of file GenericBenchmark.cc.

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

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

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 137 of file GenericBenchmark.h.

References accepted(), algo_, PFBenchmarkAlgo::deltaR(), boostedElectronIsolation_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, PFBenchmarkAlgo::matchByDeltaR(), reco::Candidate::phi(), reco::Candidate::pt(), reco::Candidate::px(), and reco::Candidate::py().

                                   {

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

}

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

private

Definition at line 308 of file GenericBenchmark.cc.

References gather_cfg::cout, BenchmarkTreeEntry::deltaEt, spr::deltaEta, BenchmarkTreeEntry::deltaEta, hiPixelPairStep_cff::deltaPhi, boostedElectronIsolation_cff::deltaR, mps_splice::entry, stringResolutionProvider_cfi::et, BenchmarkTreeEntry::et, reco::Candidate::et(), BenchmarkTreeEntry::eta, PVValHelper::eta, reco::Candidate::eta(), 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);

}

void GenericBenchmark::setfile

(

TFile *

file

)

Definition at line 408 of file GenericBenchmark.cc.

References FrontierConditions_GlobalTag_cff::file.

{
  file_=file;
}

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

Definition at line 41 of file GenericBenchmark.cc.

References BOOK1D, BOOK2D, gather_cfg::cout, debug, HiRegitMuonDetachedTripletStep_cff::DeltaEta, benchmark_cfg::doMetPlots, ET, ETA, FrontierConditions_GlobalTag_cff::file, M_PI, maxEta, trackingPOGFilters_cfi::minEta, 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");
}

void GenericBenchmark::write

(

std::string

Filename

)

Definition at line 401 of file GenericBenchmark.cc.

                                               {

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

}

Member Data Documentation

PFBenchmarkAlgo* GenericBenchmark::algo_

protected

Definition at line 132 of file GenericBenchmark.h.

Referenced by fill().

DQMStore* GenericBenchmark::dbe_

protected

Definition at line 131 of file GenericBenchmark.h.

bool GenericBenchmark::doMetPlots_

private

Definition at line 127 of file GenericBenchmark.h.

TFile* GenericBenchmark::file_

private

Definition at line 65 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaEt

private

Definition at line 67 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaEta

private

Definition at line 82 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtavsEt

private

Definition at line 83 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtavsEta

private

Definition at line 84 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtOverEtvsDeltaR

private

Definition at line 77 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtOverEtvsEt

private

Definition at line 71 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtOverEtvsEta

private

Definition at line 73 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtOverEtvsPhi

private

Definition at line 75 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtvsDeltaR

private

Definition at line 76 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtvsEt

private

Definition at line 70 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtvsEta

private

Definition at line 72 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaEtvsPhi

private

Definition at line 74 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaEx

private

Definition at line 68 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaEy

private

Definition at line 69 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaMexvsSet

private

Definition at line 119 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaPhi

private

Definition at line 86 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaPhivsEt

private

Definition at line 87 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaPhivsEta

private

Definition at line 88 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hDeltaR

private

Definition at line 90 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaRvsEt

private

Definition at line 91 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaRvsEta

private

Definition at line 92 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaSetOverSetvsSet

private

Definition at line 120 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hDeltaSetvsSet

private

Definition at line 118 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hEtaGen

private

Definition at line 98 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hEtaSeen

private

Definition at line 106 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hEtGen

private

Definition at line 97 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hEtRec

private

Definition at line 111 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtRecOverTrueEtvsTrueEt

private

Definition at line 80 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtRecvsEt

private

Definition at line 79 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hEtSeen

private

Definition at line 105 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtvsEtaGen

private

Definition at line 99 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtvsEtaSeen

private

Definition at line 108 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtvsPhiGen

private

Definition at line 100 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hEtvsPhiSeen

private

Definition at line 109 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hExRec

private

Definition at line 112 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hEyRec

private

Definition at line 113 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hNGen

private

Definition at line 103 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hNRec

private

Definition at line 94 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hPhiGen

private

Definition at line 101 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hPhiRec

private

Definition at line 114 of file GenericBenchmark.h.

Referenced by fill().

TH1F* GenericBenchmark::hPhiSeen

private

Definition at line 107 of file GenericBenchmark.h.

Referenced by fill().

TH2F* GenericBenchmark::hRecSetOverTrueSetvsTrueSet

private

Definition at line 122 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hRecSetvsTrueSet

private

Definition at line 121 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hSumEt

private

Definition at line 116 of file GenericBenchmark.h.

TH2F* GenericBenchmark::hTrueMexvsTrueSet

private

Definition at line 123 of file GenericBenchmark.h.

TH1F* GenericBenchmark::hTrueSumEt

private

Definition at line 117 of file GenericBenchmark.h.

BenchmarkTree* GenericBenchmark::tree_

private

Definition at line 125 of file GenericBenchmark.h.