|
|
|
#include <GenericBenchmark.h>
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=NULL, 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 () |
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_ |
Definition at line 24 of file GenericBenchmark.h.
| GenericBenchmark::GenericBenchmark | ( | ) |
Definition at line 37 of file GenericBenchmark.cc.
{}
| GenericBenchmark::~GenericBenchmark | ( | ) | [virtual] |
Definition at line 39 of file GenericBenchmark.cc.
{}
| 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().
| 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_, deltaR(), PFBenchmarkAlgo::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, i, j, PFBenchmarkAlgo::matchByDeltaR(), NULL, 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!=NULL );
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==NULL) 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, BenchmarkTreeEntry::deltaEta, HLTFastRecoForTau_cff::deltaEta, SiPixelRawToDigiRegional_cfi::deltaPhi, deltaR(), BenchmarkTreeEntry::et, reco::Candidate::et(), BenchmarkTreeEntry::eta, eta, reco::Candidate::eta(), NULL, reco::Candidate::phi(), 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!=NULL && met2!=NULL)
{
//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 mergeVDriftHistosByStation::file.
Referenced by METManager::addGenBenchmark().
| void GenericBenchmark::setup | ( | DQMStore * | DQM = NULL, |
| 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, DQMStore::cd(), gather_cfg::cout, debug, benchmark_cfg::doMetPlots, ET, ETA, mergeVDriftHistosByStation::file, M_PI, CommPDSkim_cfg::maxDeltaEta, maxEta, benchmark_cfg::minEta, PHI, DQMStore::pwd(), and SETAXES.
Referenced by METManager::addGenBenchmark().
{
//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.
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] |
Reimplemented in GenericBenchmarkAnalyzer.
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.
1.7.3