PFJetBenchmark Class Reference

#include <PFJetBenchmark.h>

Public Types
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement

Public Member Functions
void	gettrue (const reco::GenJet *truth, double &true_ChargedHadEnergy, double &true_NeutralHadEnergy, double &true_NeutralEmEnergy)
	PFJetBenchmark ()
void	printGenJet (const reco::GenJet *)
void	printPFJet (const reco::PFJet *)
void	process (const reco::PFJetCollection &, const reco::GenJetCollection &)
double	resChargedHadEnergyMax () const
double	resNeutralEmEnergyMax () const
double	resNeutralHadEnergyMax () const
double	resPtMax () const
void	setup (std::string Filename, bool debug, bool plotAgainstReco=false, bool onlyTwoJets=true, double deltaRMax=0.1, std::string benchmarkLabel_="ParticleFlow", double recPt=-1, double maxEta=-1, DQMStore *dbe_store=nullptr)
void	write ()
virtual	~PFJetBenchmark ()

Protected Attributes
PFBenchmarkAlgo *	algo_
DQMStore *	dbe_
bool	debug_
double	deltaRMax_
unsigned int	entry_
double	maxEta_cut
bool	onlyTwoJets_
bool	plotAgainstReco_
double	recPt_cut
double	resChargedHadEnergyMax_
double	resNeutralEmEnergyMax_
double	resNeutralHadEnergyMax_
double	resPtMax_

Private Attributes
TFile *	file_
TH2F *	hBDEtavsPt
TH2F *	hBDPhivsPt
TH1F *	hBNCH
TH2F *	hBNCH0vsPt
TH2F *	hBNCH1vsPt
TH2F *	hBNCH2vsPt
TH2F *	hBNCH3vsPt
TH2F *	hBNCH4vsPt
TH2F *	hBNCH5vsPt
TH2F *	hBNCH6vsPt
TH2F *	hBNCH7vsPt
TH2F *	hBNCHvsPt
TH1F *	hBRCHE
TH2F *	hBRCHEvsPt
TH2F *	hBRHCALvsP
TH2F *	hBRHONLvsP
TH1F *	hBRNEE
TH2F *	hBRNEEvsPt
TH1F *	hBRneut
TH2F *	hBRNEUTvsP
TH2F *	hBRneutvsPt
TH1F *	hBRNHE
TH2F *	hBRNHEvsPt
TH2F *	hBRNONLvsP
TH1F *	hBRPt
TH1F *	hBRPt100_150
TH1F *	hBRPt1250_2000
TH1F *	hBRPt150_200
TH1F *	hBRPt2000_5000
TH1F *	hBRPt200_250
TH1F *	hBRPt20_40
TH1F *	hBRPt250_300
TH1F *	hBRPt300_400
TH1F *	hBRPt400_500
TH1F *	hBRPt40_60
TH1F *	hBRPt500_750
TH1F *	hBRPt60_80
TH1F *	hBRPt750_1250
TH1F *	hBRPt80_100
TH2F *	hBRPtvsPt
TH2F *	hDEtavsEta
TH2F *	hDPhivsEta
TH2F *	hEDEtavsPt
TH2F *	hEDPhivsPt
TH1F *	hENCH
TH2F *	hENCH0vsPt
TH2F *	hENCH1vsPt
TH2F *	hENCH2vsPt
TH2F *	hENCH3vsPt
TH2F *	hENCH4vsPt
TH2F *	hENCH5vsPt
TH2F *	hENCH6vsPt
TH2F *	hENCH7vsPt
TH2F *	hENCHvsPt
TH1F *	hERCHE
TH2F *	hERCHEvsPt
TH2F *	hERHCALvsP
TH2F *	hERHONLvsP
TH1F *	hERNEE
TH2F *	hERNEEvsPt
TH1F *	hERneut
TH2F *	hERNEUTvsP
TH2F *	hERneutvsPt
TH1F *	hERNHE
TH2F *	hERNHEvsPt
TH2F *	hERNONLvsP
TH1F *	hERPt
TH1F *	hERPt100_150
TH1F *	hERPt1250_2000
TH1F *	hERPt150_200
TH1F *	hERPt2000_5000
TH1F *	hERPt200_250
TH1F *	hERPt20_40
TH1F *	hERPt250_300
TH1F *	hERPt300_400
TH1F *	hERPt400_500
TH1F *	hERPt40_60
TH1F *	hERPt500_750
TH1F *	hERPt60_80
TH1F *	hERPt750_1250
TH1F *	hERPt80_100
TH2F *	hERPtvsPt
TH2F *	hFDEtavsPt
TH2F *	hFDPhivsPt
TH1F *	hFNCH
TH2F *	hFNCH0vsPt
TH2F *	hFNCH1vsPt
TH2F *	hFNCH2vsPt
TH2F *	hFNCH3vsPt
TH2F *	hFNCH4vsPt
TH2F *	hFNCH5vsPt
TH2F *	hFNCH6vsPt
TH2F *	hFNCH7vsPt
TH2F *	hFNCHvsPt
TH1F *	hFRCHE
TH2F *	hFRCHEvsPt
TH2F *	hFRHCALvsP
TH2F *	hFRHONLvsP
TH1F *	hFRNEE
TH2F *	hFRNEEvsPt
TH1F *	hFRneut
TH2F *	hFRNEUTvsP
TH2F *	hFRneutvsPt
TH1F *	hFRNHE
TH2F *	hFRNHEvsPt
TH2F *	hFRNONLvsP
TH1F *	hFRPt
TH1F *	hFRPt100_150
TH1F *	hFRPt1250_2000
TH1F *	hFRPt150_200
TH1F *	hFRPt2000_5000
TH1F *	hFRPt200_250
TH1F *	hFRPt20_40
TH1F *	hFRPt250_300
TH1F *	hFRPt300_400
TH1F *	hFRPt400_500
TH1F *	hFRPt40_60
TH1F *	hFRPt500_750
TH1F *	hFRPt60_80
TH1F *	hFRPt750_1250
TH1F *	hFRPt80_100
TH2F *	hFRPtvsPt
TH1F *	hjetsEta
TH1F *	hjetsPt
TH2F *	hNCH0vsEta
TH2F *	hNCH1vsEta
TH2F *	hNCH2vsEta
TH2F *	hNCH3vsEta
TH2F *	hNCH4vsEta
TH2F *	hNCH5vsEta
TH2F *	hNCH6vsEta
TH2F *	hNCH7vsEta
TH2F *	hNCHvsEta
TH1F *	hNjets
TH2F *	hRCHEvsEta
TH2F *	hRHCALvsEta
TH2F *	hRHONLvsEta
TH2F *	hRNeutvsEta
TH2F *	hRNEUTvsEta
TH2F *	hRNONLvsEta
TH2F *	hRPtvsEta
std::string	outputFile_

Detailed Description

Definition at line 28 of file PFJetBenchmark.h.

Member Typedef Documentation

DQMStore

typedef dqm::legacy::DQMStore PFJetBenchmark::DQMStore

Definition at line 30 of file PFJetBenchmark.h.

MonitorElement

typedef dqm::legacy::MonitorElement PFJetBenchmark::MonitorElement

Definition at line 31 of file PFJetBenchmark.h.

Constructor & Destructor Documentation

PFJetBenchmark()

PFJetBenchmark::PFJetBenchmark

(

)

Definition at line 47 of file PFJetBenchmark.cc.

: file_(nullptr), entry_(0) {}

~PFJetBenchmark()

PFJetBenchmark::~PFJetBenchmark ( )

virtual

Definition at line 49 of file PFJetBenchmark.cc.

References file_.

                                {
  if (file_)
    file_->Close();
}

Member Function Documentation

gettrue()

void PFJetBenchmark::gettrue	(	const reco::GenJet *	truth,
		double &	true_ChargedHadEnergy,
		double &	true_NeutralHadEnergy,
		double &	true_NeutralEmEnergy
	)

Definition at line 718 of file PFJetBenchmark.cc.

References funct::abs(), MillePedeFileConverter_cfg::e, reco::LeafCandidate::energy(), reco::GenJet::getGenConstituents(), mps_fire::i, and reco::LeafCandidate::pdgId().

Referenced by process().

                                                           {
  std::vector<const GenParticle*> mcparts = truth->getGenConstituents();
  true_NeutralEmEnergy = 0.;
  true_ChargedHadEnergy = 0.;
  true_NeutralHadEnergy = 0.;
  // for each MC particle in turn
  for (unsigned i = 0; i < mcparts.size(); i++) {
    const GenParticle* mcpart = mcparts[i];
    int PDG = std::abs(mcpart->pdgId());
    double e = mcpart->energy();
    switch (PDG) {  // start PDG switch
      case 22:      // photon
        true_NeutralEmEnergy += e;
        break;
      case 211:   // pi
      case 321:   // K
      case 2212:  // p
      case 11:    //electrons (until recognised)
        true_ChargedHadEnergy += e;
        break;
      case 310:   // K_S0
      case 130:   // K_L0
      case 3122:  // Lambda0
      case 2112:  // n0
        true_NeutralHadEnergy += e;
      default:
        break;
    }  // end PDG switch
  }    // end loop on constituents.
}

printGenJet()

void PFJetBenchmark::printGenJet

(

const reco::GenJet *

truth

)

Definition at line 774 of file PFJetBenchmark.cc.

References gather_cfg::cout, reco::LeafCandidate::eta(), reco::GenJet::getGenConstituents(), mps_fire::i, reco::LeafCandidate::p(), reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), and reco::LeafCandidate::pz().

Referenced by process().

                                                        {
  std::vector<const GenParticle*> mcparts = truth->getGenConstituents();
  cout << "GenJet p/px/py/pz/pt: " << truth->p() << '/' << truth->px() << '/' << truth->py() << '/' << truth->pz()
       << '/' << truth->pt() << endl
       << "    eta/phi: " << truth->eta() << '/' << truth->phi() << endl
       << "    # of constituents: " << mcparts.size() << endl;
  cout << "    constituents:" << endl;
  for (unsigned i = 0; i < mcparts.size(); i++) {
    const GenParticle* mcpart = mcparts[i];
    cout << "      #" << i << "  PDG code:" << mcpart->pdgId() << ", p/pt/eta/phi: " << mcpart->p() << '/'
         << mcpart->pt() << '/' << mcpart->eta() << '/' << mcpart->phi() << endl;
  }
}

printPFJet()

void PFJetBenchmark::printPFJet

(

const reco::PFJet *

pfj

)

Definition at line 752 of file PFJetBenchmark.cc.

References reco::PFJet::chargedEmEnergy(), reco::PFJet::chargedHadronEnergy(), reco::PFJet::chargedMuEnergy(), reco::PFJet::chargedMultiplicity(), gather_cfg::cout, reco::LeafCandidate::eta(), alignBH_cfg::fixed, reco::PFJet::neutralEmEnergy(), reco::PFJet::neutralHadronEnergy(), reco::PFJet::neutralMultiplicity(), reco::LeafCandidate::p(), reco::LeafCandidate::phi(), reco::PFJet::print(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), and reco::LeafCandidate::pz().

Referenced by process().

                                                    {
  cout << setiosflags(ios::right);
  cout << setiosflags(ios::fixed);
  cout << setprecision(3);

  cout << "PFJet  p/px/py/pz/pt: " << pfj->p() << "/" << pfj->px() << "/" << pfj->py() << "/" << pfj->pz() << "/"
       << pfj->pt() << endl
       << "    eta/phi: " << pfj->eta() << "/" << pfj->phi() << endl
       << "    PFJet specific:" << std::endl
       << "      charged/neutral hadrons energy: " << pfj->chargedHadronEnergy() << '/' << pfj->neutralHadronEnergy()
       << endl
       << "      charged/neutral em energy: " << pfj->chargedEmEnergy() << '/' << pfj->neutralEmEnergy() << endl
       << "      charged muon energy: " << pfj->chargedMuEnergy() << '/' << endl
       << "      charged/neutral multiplicity: " << pfj->chargedMultiplicity() << '/' << pfj->neutralMultiplicity()
       << endl;

  // And print the constituents
  std::cout << pfj->print() << std::endl;

  cout << resetiosflags(ios::right | ios::fixed);
}

process()

void PFJetBenchmark::process	(	const reco::PFJetCollection &	pfJets,
		const reco::GenJetCollection &	genJets
	)

Definition at line 232 of file PFJetBenchmark.cc.

References funct::abs(), algo_, Barrel, reco::PFJet::chargedHadronEnergy(), reco::PFJet::chargedMultiplicity(), gather_cfg::cout, debug_, PFBenchmarkAlgo::deltaR(), PbPb_ZMuSkimMuonDPG_cff::deltaR, deltaRMax_, entry_, reco::LeafCandidate::eta(), L1CaloJetHTTProducer_cfi::genJets, reco::PFJet::getPFConstituents(), gettrue(), hBDEtavsPt, hBDPhivsPt, hBNCH, hBNCH0vsPt, hBNCH1vsPt, hBNCH2vsPt, hBNCH3vsPt, hBNCH4vsPt, hBNCH5vsPt, hBNCH6vsPt, hBNCH7vsPt, hBNCHvsPt, hBRCHE, hBRCHEvsPt, hBRHCALvsP, hBRHONLvsP, hBRNEE, hBRNEEvsPt, hBRneut, hBRNEUTvsP, hBRneutvsPt, hBRNHE, hBRNHEvsPt, hBRNONLvsP, hBRPt, hBRPt100_150, hBRPt1250_2000, hBRPt150_200, hBRPt2000_5000, hBRPt200_250, hBRPt20_40, hBRPt250_300, hBRPt300_400, hBRPt400_500, hBRPt40_60, hBRPt500_750, hBRPt60_80, hBRPt750_1250, hBRPt80_100, hBRPtvsPt, hDEtavsEta, hDPhivsEta, hEDEtavsPt, hEDPhivsPt, hENCH, hENCH0vsPt, hENCH1vsPt, hENCH2vsPt, hENCH3vsPt, hENCH4vsPt, hENCH5vsPt, hENCH6vsPt, hENCH7vsPt, hENCHvsPt, hERCHE, hERCHEvsPt, hERHCALvsP, hERHONLvsP, hERNEE, hERNEEvsPt, hERneut, hERNEUTvsP, hERneutvsPt, hERNHE, hERNHEvsPt, hERNONLvsP, hERPt, hERPt100_150, hERPt1250_2000, hERPt150_200, hERPt2000_5000, hERPt200_250, hERPt20_40, hERPt250_300, hERPt300_400, hERPt400_500, hERPt40_60, hERPt500_750, hERPt60_80, hERPt750_1250, hERPt80_100, hERPtvsPt, hFDEtavsPt, hFDPhivsPt, hFRCHE, hFRCHEvsPt, hFRHCALvsP, hFRHONLvsP, hFRNEE, hFRNEEvsPt, hFRneut, hFRNEUTvsP, hFRneutvsPt, hFRNHE, hFRNHEvsPt, hFRNONLvsP, hFRPt, hFRPt100_150, hFRPt1250_2000, hFRPt150_200, hFRPt2000_5000, hFRPt200_250, hFRPt20_40, hFRPt250_300, hFRPt300_400, hFRPt400_500, hFRPt40_60, hFRPt500_750, hFRPt60_80, hFRPt750_1250, hFRPt80_100, hFRPtvsPt, hjetsEta, hjetsPt, hNCH0vsEta, hNCH1vsEta, hNCH2vsEta, hNCH3vsEta, hNCH4vsEta, hNCH5vsEta, hNCH6vsEta, hNCH7vsEta, hNCHvsEta, hNjets, hRCHEvsEta, hRHCALvsEta, hRHONLvsEta, hRNeutvsEta, hRNEUTvsEta, hRNONLvsEta, hRPtvsEta, mps_fire::i, edm::Ref< C, T, F >::isNull(), dqmiolumiharvest::j, PFBenchmarkAlgo::matchByDeltaR(), maxEta_cut, reco::PFJet::neutralEmEnergy(), reco::PFJet::neutralHadronEnergy(), onlyTwoJets_, reco::LeafCandidate::p(), pfJetBenchmark_cfi::pfJets, reco::LeafCandidate::phi(), plotAgainstReco_, printGenJet(), printPFJet(), DiDispStaMuonMonitor_cfi::pt, reco::LeafCandidate::pt(), recPt_cut, resChargedHadEnergyMax_, resNeutralEmEnergyMax_, resNeutralHadEnergyMax_, and resPtMax_.

Referenced by PFJetBenchmarkAnalyzer::analyze().

                                                                                                   {
  // loop over reco  pf  jets
  resPtMax_ = 0.;
  resChargedHadEnergyMax_ = 0.;
  resNeutralHadEnergyMax_ = 0.;
  resNeutralEmEnergyMax_ = 0.;
  int NPFJets = 0;

  for (unsigned i = 0; i < pfJets.size(); i++) {
    // Count the number of jets with a larger energy
    unsigned highJets = 0;
    for (unsigned j = 0; j < pfJets.size(); j++) {
      if (j != i && pfJets[j].pt() > pfJets[i].pt())
        highJets++;
    }
    if (onlyTwoJets_ && highJets > 1)
      continue;

    const reco::PFJet& pfj = pfJets[i];
    double rec_pt = pfj.pt();
    double rec_eta = pfj.eta();
    double rec_phi = pfj.phi();

    // skip PFjets with pt < recPt_cut GeV
    if (rec_pt < recPt_cut and recPt_cut != -1.)
      continue;
    // skip PFjets with eta > maxEta_cut
    if (fabs(rec_eta) > maxEta_cut and maxEta_cut != -1.)
      continue;

    NPFJets++;

    // fill inclusive PFjet distribution pt > 20 GeV
    hNjets->Fill(NPFJets);
    hjetsPt->Fill(rec_pt);
    hjetsEta->Fill(rec_eta);

    // separate Barrel PFJets from Endcap PFJets
    bool Barrel = false;
    bool Endcap = false;
    bool Forward = false;
    if (std::abs(rec_eta) < 1.4)
      Barrel = true;
    if (std::abs(rec_eta) > 1.6 && std::abs(rec_eta) < 2.4)
      Endcap = true;
    if (std::abs(rec_eta) > 2.5 && std::abs(rec_eta) < 2.9)
      Forward = true;
    if (std::abs(rec_eta) > 3.1 && std::abs(rec_eta) < 4.7)
      Forward = true;

    // do only barrel for now
    //  if(!Barrel) continue;

    // look for the closets gen Jet : truth
    const GenJet* truth = algo_->matchByDeltaR(&pfj, &genJets);
    if (!truth)
      continue;
    double deltaR = algo_->deltaR(&pfj, truth);
    // check deltaR is small enough
    if (deltaR < deltaRMax_ || (abs(rec_eta) > 2.5 && deltaR < 0.2) ||
        deltaRMax_ == -1.0) {  //start case deltaR < deltaRMax

      // generate histograms comparing the reco and truth candidate (truth = closest in delta-R)
      // get the quantities to place on the denominator and/or divide by
      double pt_denom;
      double true_E = truth->p();
      double true_pt = truth->pt();
      double true_eta = truth->eta();
      double true_phi = truth->phi();

      if (plotAgainstReco_) {
        pt_denom = rec_pt;
      } else {
        pt_denom = true_pt;
      }
      // get true specific quantities
      double true_ChargedHadEnergy;
      double true_NeutralHadEnergy;
      double true_NeutralEmEnergy;
      gettrue(truth, true_ChargedHadEnergy, true_NeutralHadEnergy, true_NeutralEmEnergy);
      double true_NeutralEnergy = true_NeutralHadEnergy + true_NeutralEmEnergy;
      double rec_ChargedHadEnergy = pfj.chargedHadronEnergy();
      double rec_NeutralHadEnergy = pfj.neutralHadronEnergy();
      double rec_NeutralEmEnergy = pfj.neutralEmEnergy();
      double rec_NeutralEnergy = rec_NeutralHadEnergy + rec_NeutralEmEnergy;
      double rec_ChargedMultiplicity = pfj.chargedMultiplicity();
      std::vector<PFCandidatePtr> constituents = pfj.getPFConstituents();
      std::vector<unsigned int> chMult(9, static_cast<unsigned int>(0));
      for (unsigned ic = 0; ic < constituents.size(); ++ic) {
        if (constituents[ic]->particleId() > 3)
          continue;
        reco::TrackRef trackRef = constituents[ic]->trackRef();
        if (trackRef.isNull()) {
          //std::cout << "Warning in entry " << entry_
          //        << " : a track with Id " << constituents[ic]->particleId()
          //        << " has no track ref.." << std::endl;
          continue;
        }
        unsigned int iter = trackRef->algo() > 6 ? 6 : trackRef->algo();
        ++(chMult[iter]);
      }

      bool plot1 = false;
      bool plot2 = false;
      bool plot3 = false;
      bool plot4 = false;
      bool plot5 = false;
      bool plot6 = false;
      bool plot7 = false;
      double cut1 = 0.0001;
      double cut2 = 0.0001;
      double cut3 = 0.0001;
      double cut4 = 0.0001;
      double cut5 = 0.0001;
      double cut6 = 0.0001;
      double cut7 = 0.0001;
      double resPt = 0.;
      double resChargedHadEnergy = 0.;
      double resNeutralHadEnergy = 0.;
      double resNeutralEmEnergy = 0.;
      double resNeutralEnergy = 0.;

      double resHCALEnergy = 0.;
      double resNEUTEnergy = 0.;
      if (rec_NeutralHadEnergy > cut6 && rec_ChargedHadEnergy < cut1) {
        double true_NEUTEnergy = true_NeutralHadEnergy + true_NeutralEmEnergy;
        double true_HCALEnergy = true_NEUTEnergy - rec_NeutralEmEnergy;
        double rec_NEUTEnergy = rec_NeutralHadEnergy + rec_NeutralEmEnergy;
        double rec_HCALEnergy = rec_NeutralHadEnergy;
        resHCALEnergy = (rec_HCALEnergy - true_HCALEnergy) / rec_HCALEnergy;
        resNEUTEnergy = (rec_NEUTEnergy - true_NEUTEnergy) / rec_NEUTEnergy;
        if (rec_NeutralEmEnergy > cut7) {
          plot6 = true;
        } else {
          plot7 = true;
        }
      }

      // get relative delta quantities (protect against division by zero!)
      if (true_pt > 0.0001) {
        resPt = (rec_pt - true_pt) / true_pt;
        plot1 = true;
      }
      if (true_ChargedHadEnergy > cut1) {
        resChargedHadEnergy = (rec_ChargedHadEnergy - true_ChargedHadEnergy) / true_ChargedHadEnergy;
        plot2 = true;
      }
      if (true_NeutralHadEnergy > cut2) {
        resNeutralHadEnergy = (rec_NeutralHadEnergy - true_NeutralHadEnergy) / true_NeutralHadEnergy;
        plot3 = true;
      } else if (rec_NeutralHadEnergy > cut3) {
        resNeutralHadEnergy = (rec_NeutralHadEnergy - true_NeutralHadEnergy) / rec_NeutralHadEnergy;
        plot3 = true;
      }
      if (true_NeutralEmEnergy > cut4) {
        resNeutralEmEnergy = (rec_NeutralEmEnergy - true_NeutralEmEnergy) / true_NeutralEmEnergy;
        plot4 = true;
      }
      if (true_NeutralEnergy > cut5) {
        resNeutralEnergy = (rec_NeutralEnergy - true_NeutralEnergy) / true_NeutralEnergy;
        plot5 = true;
      }

      //double deltaEta = algo_->deltaEta(&pfj, truth);
      //double deltaPhi = algo_->deltaPhi(&pfj, truth);

      // Print outliers for further debugging
      if ((resPt > 0.2 && true_pt > 100.) || (resPt < -0.5 && true_pt > 100.)) {
        //if ( ( true_pt > 50. &&
        //     ( ( truth->eta()>3.0 && rec_eta-truth->eta() < -0.1 ) ||
        //       ( truth->eta()<-3.0 && rec_eta-truth->eta() > 0.1 ) ))) {
        std::cout << "Entry " << entry_ << " resPt = " << resPt << " resCharged  " << resChargedHadEnergy
                  << " resNeutralHad  " << resNeutralHadEnergy << " resNeutralEm  " << resNeutralEmEnergy
                  << " pT (T/R) " << true_pt << "/" << rec_pt << " Eta (T/R) " << truth->eta() << "/" << rec_eta
                  << " Phi (T/R) " << truth->phi() << "/" << rec_phi << std::endl;

        // check overlapping PF jets
        const reco::PFJet* pfoj = nullptr;
        double dRo = 1E9;
        for (unsigned j = 0; j < pfJets.size(); j++) {
          const reco::PFJet& pfo = pfJets[j];
          if (j != i && algo_->deltaR(&pfj, &pfo) < dRo && pfo.pt() > 0.25 * pfj.pt()) {
            dRo = algo_->deltaR(&pfj, &pfo);
            pfoj = &pfo;
          }
        }

        // Check overlapping Gen Jet
        math::XYZTLorentzVector overlappinGenJet(0., 0., 0., 0.);
        const reco::GenJet* genoj = nullptr;
        double dRgo = 1E9;
        for (unsigned j = 0; j < genJets.size(); j++) {
          const reco::GenJet* gjo = &(genJets[j]);
          if (gjo != truth && algo_->deltaR(truth, gjo) < dRgo && gjo->pt() > 0.25 * truth->pt()) {
            dRgo = algo_->deltaR(truth, gjo);
            genoj = gjo;
          }
        }

        if (dRo < 0.8 && dRgo < 0.8 && algo_->deltaR(genoj, pfoj) < 2. * deltaRMax_)
          std::cout << "Excess probably due to overlapping jets (DR = " << algo_->deltaR(genoj, pfoj) << "),"
                    << " at DeltaR(T/R) = " << dRgo << "/" << dRo << " with pT(T/R) " << genoj->pt() << "/"
                    << pfoj->pt() << " and Eta (T/R) " << genoj->eta() << "/" << pfoj->eta() << " and Phi (T/R) "
                    << genoj->phi() << "/" << pfoj->phi() << std::endl;
      }

      if (std::abs(resPt) > std::abs(resPtMax_))
        resPtMax_ = resPt;
      if (std::abs(resChargedHadEnergy) > std::abs(resChargedHadEnergyMax_))
        resChargedHadEnergyMax_ = resChargedHadEnergy;
      if (std::abs(resNeutralHadEnergy) > std::abs(resNeutralHadEnergyMax_))
        resNeutralHadEnergyMax_ = resNeutralHadEnergy;
      if (std::abs(resNeutralEmEnergy) > std::abs(resNeutralEmEnergyMax_))
        resNeutralEmEnergyMax_ = resNeutralEmEnergy;
      if (debug_) {
        cout << i << "  =========PFJet Pt " << rec_pt << " eta " << rec_eta << " phi " << rec_phi
             << " Charged Had Energy " << rec_ChargedHadEnergy << " Neutral Had Energy " << rec_NeutralHadEnergy
             << " Neutral elm Energy " << rec_NeutralEmEnergy << endl;
        cout << " matching Gen Jet Pt " << true_pt << " eta " << truth->eta() << " phi " << truth->phi()
             << " Charged Had Energy " << true_ChargedHadEnergy << " Neutral Had Energy " << true_NeutralHadEnergy
             << " Neutral elm Energy " << true_NeutralEmEnergy << endl;
        printPFJet(&pfj);
        //      cout<<pfj.print()<<endl;
        printGenJet(truth);
        //cout <<truth->print()<<endl;

        cout << "==============deltaR " << deltaR << "  resPt " << resPt << " resChargedHadEnergy "
             << resChargedHadEnergy << " resNeutralHadEnergy " << resNeutralHadEnergy << " resNeutralEmEnergy "
             << resNeutralEmEnergy << endl;
      }

      if (plot1) {
        if (rec_eta > 0.)
          hDEtavsEta->Fill(true_eta, rec_eta - true_eta);
        else
          hDEtavsEta->Fill(true_eta, -rec_eta + true_eta);
        hDPhivsEta->Fill(true_eta, rec_phi - true_phi);

        hRPtvsEta->Fill(true_eta, resPt);
        hNCHvsEta->Fill(true_eta, rec_ChargedMultiplicity);
        hNCH0vsEta->Fill(true_eta, chMult[0]);
        hNCH1vsEta->Fill(true_eta, chMult[1]);
        hNCH2vsEta->Fill(true_eta, chMult[2]);
        hNCH3vsEta->Fill(true_eta, chMult[3]);
        hNCH4vsEta->Fill(true_eta, chMult[4]);
        hNCH5vsEta->Fill(true_eta, chMult[5]);
        hNCH6vsEta->Fill(true_eta, chMult[6]);
        hNCH7vsEta->Fill(true_eta, chMult[7]);
      }
      if (plot2)
        hRCHEvsEta->Fill(true_eta, resChargedHadEnergy);
      if (plot5)
        hRNeutvsEta->Fill(true_eta, resNeutralEnergy);
      if (plot6) {
        hRHCALvsEta->Fill(true_eta, resHCALEnergy);
        hRNEUTvsEta->Fill(true_eta, resNEUTEnergy);
      }
      if (plot7) {
        hRHONLvsEta->Fill(true_eta, resHCALEnergy);
        hRNONLvsEta->Fill(true_eta, resNEUTEnergy);
      }

      // fill histograms for relative delta quantitites of matched jets
      // delta Pt or E quantities for Barrel
      if (Barrel) {
        if (plot1) {
          hBRPt->Fill(resPt);
          if (pt_denom > 20. && pt_denom < 40.)
            hBRPt20_40->Fill(resPt);
          if (pt_denom > 40. && pt_denom < 60.)
            hBRPt40_60->Fill(resPt);
          if (pt_denom > 60. && pt_denom < 80.)
            hBRPt60_80->Fill(resPt);
          if (pt_denom > 80. && pt_denom < 100.)
            hBRPt80_100->Fill(resPt);
          if (pt_denom > 100. && pt_denom < 150.)
            hBRPt100_150->Fill(resPt);
          if (pt_denom > 150. && pt_denom < 200.)
            hBRPt150_200->Fill(resPt);
          if (pt_denom > 200. && pt_denom < 250.)
            hBRPt200_250->Fill(resPt);
          if (pt_denom > 250. && pt_denom < 300.)
            hBRPt250_300->Fill(resPt);
          if (pt_denom > 300. && pt_denom < 400.)
            hBRPt300_400->Fill(resPt);
          if (pt_denom > 400. && pt_denom < 500.)
            hBRPt400_500->Fill(resPt);
          if (pt_denom > 500. && pt_denom < 750.)
            hBRPt500_750->Fill(resPt);
          if (pt_denom > 750. && pt_denom < 1250.)
            hBRPt750_1250->Fill(resPt);
          if (pt_denom > 1250. && pt_denom < 2000.)
            hBRPt1250_2000->Fill(resPt);
          if (pt_denom > 2000. && pt_denom < 5000.)
            hBRPt2000_5000->Fill(resPt);
          hBNCH->Fill(rec_ChargedMultiplicity);
          hBNCH0vsPt->Fill(pt_denom, chMult[0]);
          hBNCH1vsPt->Fill(pt_denom, chMult[1]);
          hBNCH2vsPt->Fill(pt_denom, chMult[2]);
          hBNCH3vsPt->Fill(pt_denom, chMult[3]);
          hBNCH4vsPt->Fill(pt_denom, chMult[4]);
          hBNCH5vsPt->Fill(pt_denom, chMult[5]);
          hBNCH6vsPt->Fill(pt_denom, chMult[6]);
          hBNCH7vsPt->Fill(pt_denom, chMult[7]);
          hBNCHvsPt->Fill(pt_denom, rec_ChargedMultiplicity);
          if (rec_eta > 0.)
            hBDEtavsPt->Fill(pt_denom, rec_eta - true_eta);
          else
            hBDEtavsPt->Fill(pt_denom, -rec_eta + true_eta);
          hBDPhivsPt->Fill(pt_denom, rec_phi - true_phi);
        }
        if (plot2)
          hBRCHE->Fill(resChargedHadEnergy);
        if (plot3)
          hBRNHE->Fill(resNeutralHadEnergy);
        if (plot4)
          hBRNEE->Fill(resNeutralEmEnergy);
        if (plot5)
          hBRneut->Fill(resNeutralEnergy);
        if (plot1)
          hBRPtvsPt->Fill(pt_denom, resPt);
        if (plot2)
          hBRCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
        if (plot3)
          hBRNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
        if (plot4)
          hBRNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
        if (plot5)
          hBRneutvsPt->Fill(pt_denom, resNeutralEnergy);
        if (plot6) {
          hBRHCALvsP->Fill(true_E, resHCALEnergy);
          hBRNEUTvsP->Fill(true_E, resNEUTEnergy);
        }
        if (plot7) {
          hBRHONLvsP->Fill(true_E, resHCALEnergy);
          hBRNONLvsP->Fill(true_E, resNEUTEnergy);
        }
      }
      // delta Pt or E quantities for Endcap
      if (Endcap) {
        if (plot1) {
          hERPt->Fill(resPt);
          if (pt_denom > 20. && pt_denom < 40.)
            hERPt20_40->Fill(resPt);
          if (pt_denom > 40. && pt_denom < 60.)
            hERPt40_60->Fill(resPt);
          if (pt_denom > 60. && pt_denom < 80.)
            hERPt60_80->Fill(resPt);
          if (pt_denom > 80. && pt_denom < 100.)
            hERPt80_100->Fill(resPt);
          if (pt_denom > 100. && pt_denom < 150.)
            hERPt100_150->Fill(resPt);
          if (pt_denom > 150. && pt_denom < 200.)
            hERPt150_200->Fill(resPt);
          if (pt_denom > 200. && pt_denom < 250.)
            hERPt200_250->Fill(resPt);
          if (pt_denom > 250. && pt_denom < 300.)
            hERPt250_300->Fill(resPt);
          if (pt_denom > 300. && pt_denom < 400.)
            hERPt300_400->Fill(resPt);
          if (pt_denom > 400. && pt_denom < 500.)
            hERPt400_500->Fill(resPt);
          if (pt_denom > 500. && pt_denom < 750.)
            hERPt500_750->Fill(resPt);
          if (pt_denom > 750. && pt_denom < 1250.)
            hERPt750_1250->Fill(resPt);
          if (pt_denom > 1250. && pt_denom < 2000.)
            hERPt1250_2000->Fill(resPt);
          if (pt_denom > 2000. && pt_denom < 5000.)
            hERPt2000_5000->Fill(resPt);
          hENCH->Fill(rec_ChargedMultiplicity);
          hENCHvsPt->Fill(pt_denom, rec_ChargedMultiplicity);
          hENCH0vsPt->Fill(pt_denom, chMult[0]);
          hENCH1vsPt->Fill(pt_denom, chMult[1]);
          hENCH2vsPt->Fill(pt_denom, chMult[2]);
          hENCH3vsPt->Fill(pt_denom, chMult[3]);
          hENCH4vsPt->Fill(pt_denom, chMult[4]);
          hENCH5vsPt->Fill(pt_denom, chMult[5]);
          hENCH6vsPt->Fill(pt_denom, chMult[6]);
          hENCH7vsPt->Fill(pt_denom, chMult[7]);
          if (rec_eta > 0.)
            hEDEtavsPt->Fill(pt_denom, rec_eta - true_eta);
          else
            hEDEtavsPt->Fill(pt_denom, -rec_eta + true_eta);
          hEDPhivsPt->Fill(pt_denom, rec_phi - true_phi);
        }
        if (plot2)
          hERCHE->Fill(resChargedHadEnergy);
        if (plot3)
          hERNHE->Fill(resNeutralHadEnergy);
        if (plot4)
          hERNEE->Fill(resNeutralEmEnergy);
        if (plot5)
          hERneut->Fill(resNeutralEnergy);
        if (plot1)
          hERPtvsPt->Fill(pt_denom, resPt);
        if (plot2)
          hERCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
        if (plot3)
          hERNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
        if (plot4)
          hERNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
        if (plot5)
          hERneutvsPt->Fill(pt_denom, resNeutralEnergy);
        if (plot6) {
          hERHCALvsP->Fill(true_E, resHCALEnergy);
          hERNEUTvsP->Fill(true_E, resNEUTEnergy);
        }
        if (plot7) {
          hERHONLvsP->Fill(true_E, resHCALEnergy);
          hERNONLvsP->Fill(true_E, resNEUTEnergy);
        }
      }
      // delta Pt or E quantities for Forward
      if (Forward) {
        if (plot1) {
          hFRPt->Fill(resPt);
          if (pt_denom > 20. && pt_denom < 40.)
            hFRPt20_40->Fill(resPt);
          if (pt_denom > 40. && pt_denom < 60.)
            hFRPt40_60->Fill(resPt);
          if (pt_denom > 60. && pt_denom < 80.)
            hFRPt60_80->Fill(resPt);
          if (pt_denom > 80. && pt_denom < 100.)
            hFRPt80_100->Fill(resPt);
          if (pt_denom > 100. && pt_denom < 150.)
            hFRPt100_150->Fill(resPt);
          if (pt_denom > 150. && pt_denom < 200.)
            hFRPt150_200->Fill(resPt);
          if (pt_denom > 200. && pt_denom < 250.)
            hFRPt200_250->Fill(resPt);
          if (pt_denom > 250. && pt_denom < 300.)
            hFRPt250_300->Fill(resPt);
          if (pt_denom > 300. && pt_denom < 400.)
            hFRPt300_400->Fill(resPt);
          if (pt_denom > 400. && pt_denom < 500.)
            hFRPt400_500->Fill(resPt);
          if (pt_denom > 500. && pt_denom < 750.)
            hFRPt500_750->Fill(resPt);
          if (pt_denom > 750. && pt_denom < 1250.)
            hFRPt750_1250->Fill(resPt);
          if (pt_denom > 1250. && pt_denom < 2000.)
            hFRPt1250_2000->Fill(resPt);
          if (pt_denom > 2000. && pt_denom < 5000.)
            hFRPt2000_5000->Fill(resPt);
          if (rec_eta > 0.)
            hFDEtavsPt->Fill(pt_denom, rec_eta - true_eta);
          else
            hFDEtavsPt->Fill(pt_denom, -rec_eta + true_eta);
          hFDPhivsPt->Fill(pt_denom, rec_phi - true_phi);
        }
        if (plot2)
          hFRCHE->Fill(resChargedHadEnergy);
        if (plot3)
          hFRNHE->Fill(resNeutralHadEnergy);
        if (plot4)
          hFRNEE->Fill(resNeutralEmEnergy);
        if (plot5)
          hFRneut->Fill(resNeutralEnergy);
        if (plot1)
          hFRPtvsPt->Fill(pt_denom, resPt);
        if (plot2)
          hFRCHEvsPt->Fill(pt_denom, resChargedHadEnergy);
        if (plot3)
          hFRNHEvsPt->Fill(pt_denom, resNeutralHadEnergy);
        if (plot4)
          hFRNEEvsPt->Fill(pt_denom, resNeutralEmEnergy);
        if (plot5)
          hFRneutvsPt->Fill(pt_denom, resNeutralEnergy);
        if (plot6) {
          hFRHCALvsP->Fill(true_E, resHCALEnergy);
          hFRNEUTvsP->Fill(true_E, resNEUTEnergy);
        }
        if (plot7) {
          hFRHONLvsP->Fill(true_E, resHCALEnergy);
          hFRNONLvsP->Fill(true_E, resNEUTEnergy);
        }
      }
    }  // end case deltaR < deltaRMax

  }  // i loop on pf Jets

  // Increment counter
  entry_++;
}

resChargedHadEnergyMax()

double PFJetBenchmark::resChargedHadEnergyMax ( ) const

inline

Definition at line 53 of file PFJetBenchmark.h.

References resChargedHadEnergyMax_.

{ return resChargedHadEnergyMax_; };

resNeutralEmEnergyMax()

double PFJetBenchmark::resNeutralEmEnergyMax ( ) const

inline

Definition at line 55 of file PFJetBenchmark.h.

References resNeutralEmEnergyMax_.

{ return resNeutralEmEnergyMax_; };

resNeutralHadEnergyMax()

double PFJetBenchmark::resNeutralHadEnergyMax ( ) const

inline

Definition at line 54 of file PFJetBenchmark.h.

References resNeutralHadEnergyMax_.

{ return resNeutralHadEnergyMax_; };

resPtMax()

double PFJetBenchmark::resPtMax ( ) const

inline

Definition at line 52 of file PFJetBenchmark.h.

References resPtMax_.

{ return resPtMax_; };

setup()

void PFJetBenchmark::setup	(	std::string	Filename,
		bool	debug,
		bool	plotAgainstReco = false,
		bool	onlyTwoJets = true,
		double	deltaRMax = 0.1,
		std::string	benchmarkLabel_ = "ParticleFlow",
		double	recPt = -1,
		double	maxEta = -1,
		DQMStore *	dbe_store = nullptr
	)

Definition at line 69 of file PFJetBenchmark.cc.

References benchmarkLabel_, BOOK1D, BOOK2D, gather_cfg::cout, dbe_, DBOOK1D, DBOOK2D, debug, debug_, deltaRMax, deltaRMax_, DSETAXES, ECAL, PVValHelper::eta, file_, maxEta, maxEta_cut, HLT_2022v12_cff::NCH, ECF_cff::Njets, onlyTwoJets, onlyTwoJets_, outputFile_, castor_dqm_sourceclient_file_cfg::path, phi, plotAgainstReco, plotAgainstReco_, PT, recPt, recPt_cut, SETAXES, and dqm::implementation::DQMStore::setCurrentFolder().

Referenced by PFJetBenchmarkAnalyzer::PFJetBenchmarkAnalyzer().

                                                {
  debug_ = debug;
  plotAgainstReco_ = plotAgainstReco;
  onlyTwoJets_ = onlyTwoJets;
  deltaRMax_ = deltaRMax;
  outputFile_ = Filename;
  recPt_cut = recPt;
  maxEta_cut = maxEta;
  file_ = nullptr;
  dbe_ = dbe_store;
  // print parameters
  cout << "PFJetBenchmark Setup parameters ==============================================" << endl;
  cout << "Filename to write histograms " << Filename << endl;
  cout << "PFJetBenchmark debug " << debug_ << endl;
  cout << "plotAgainstReco " << plotAgainstReco_ << endl;
  cout << "onlyTwoJets " << onlyTwoJets_ << endl;
  cout << "deltaRMax " << deltaRMax << endl;
  cout << "benchmarkLabel " << benchmarkLabel_ << endl;
  cout << "recPt_cut " << recPt_cut << endl;
  cout << "maxEta_cut " << maxEta_cut << endl;

  // Book histogram

  // Establish DQM Store
  string path = "PFTask/Benchmarks/" + benchmarkLabel_ + "/";
  if (plotAgainstReco)
    path += "Reco";
  else
    path += "Gen";
  if (dbe_) {
    dbe_->setCurrentFolder(path);
  } else {
    file_ = new TFile(outputFile_.c_str(), "recreate");
    //    TTree * tr = new TTree("PFTast");
    //    tr->Branch("Benchmarks/ParticleFlow")
    cout << "Info: DQM is not available to provide data storage service. Using TFile to save histograms. " << endl;
  }
  // Jets inclusive  distributions  (Pt > 20 or specified recPt GeV)
  char cutString[35];
  sprintf(cutString, "Jet multiplicity P_{T}>%4.1f GeV", recPt_cut);
  BOOK1D(Njets, cutString, 50, 0, 50);

  BOOK1D(jetsPt, "Jets P_{T} Distribution", 100, 0, 500);

  sprintf(cutString, "Jets #eta Distribution |#eta|<%4.1f", maxEta_cut);
  BOOK1D(jetsEta, cutString, 100, -5, 5);

  BOOK2D(RPtvsEta, "#DeltaP_{T}/P_{T} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RNeutvsEta, "R_{Neutral} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RNEUTvsEta, "R_{HCAL+ECAL} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RNONLvsEta, "R_{HCAL+ECAL - Hcal Only} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RHCALvsEta, "R_{HCAL} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RHONLvsEta, "R_{HCAL only} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(RCHEvsEta, "R_{Charged} vs #eta", 200, -5., 5., 200, -1, 1);
  BOOK2D(NCHvsEta, "N_{Charged} vs #eta", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH0vsEta, "N_{Charged} vs #eta, iter 0", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH1vsEta, "N_{Charged} vs #eta, iter 1", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH2vsEta, "N_{Charged} vs #eta, iter 2", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH3vsEta, "N_{Charged} vs #eta, iter 3", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH4vsEta, "N_{Charged} vs #eta, iter 4", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH5vsEta, "N_{Charged} vs #eta, iter 5", 200, -5., 5., 200, 0., 200.);
  BOOK2D(NCH6vsEta, "N_{Charged} vs #eta, iter 6", 200, -5., 5., 200, 0., 200.);
  // delta Pt or E quantities for Barrel
  DBOOK1D(RPt, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RCHE, #DeltaE / E(charged had), 80, -2, 2);
  DBOOK1D(RNHE, #DeltaE / E(neutral had), 80, -2, 2);
  DBOOK1D(RNEE, #DeltaE / E(neutral em), 80, -2, 2);
  DBOOK1D(Rneut, #DeltaE / E(neutral), 80, -2, 2);
  DBOOK1D(NCH, #N_{charged}, 200, 0., 200.);
  DBOOK2D(RPtvsPt, #DeltaP_{T} / P_{T} vs P_{T}, 250, 0, 500, 200, -1, 1);  //used to be 50 bin for each in x-direction
  DBOOK2D(RCHEvsPt, #DeltaE / E(charged had) vs P_{T}, 250, 0, 500, 120, -1, 2);
  DBOOK2D(RNHEvsPt, #DeltaE / E(neutral had) vs P_{T}, 250, 0, 500, 120, -1, 2);
  DBOOK2D(RNEEvsPt, #DeltaE / E(neutral em) vs P_{T}, 250, 0, 500, 120, -1, 2);
  DBOOK2D(RneutvsPt, #DeltaE / E(neutral) vs P_{T}, 250, 0, 500, 120, -1, 2);
  DBOOK2D(NCHvsPt, N_{charged} vs P_{T}, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH0vsPt, N_{charged} vs P_{T} iter 0, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH1vsPt, N_{charged} vs P_{T} iter 1, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH2vsPt, N_{charged} vs P_{T} iter 2, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH3vsPt, N_{charged} vs P_{T} iter 3, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH4vsPt, N_{charged} vs P_{T} iter 4, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH5vsPt, N_{charged} vs P_{T} iter 5, 250, 0, 500, 200, 0., 200.);
  DBOOK2D(NCH6vsPt, N_{charged} vs P_{T} iter 6, 250, 0, 500, 200, 0., 200.);

  DBOOK2D(RNEUTvsP, #DeltaE / E(ECAL + HCAL) vs P, 250, 0, 1000, 150, -1.5, 1.5);
  DBOOK2D(RNONLvsP, #DeltaE / E(ECAL + HCAL - only) vs P, 250, 0, 1000, 150, -1.5, 1.5);
  DBOOK2D(RHCALvsP, #DeltaE / E(HCAL) vs P, 250, 0, 1000, 150, -1.5, 1.5);
  DBOOK2D(RHONLvsP, #DeltaE / E(HCAL only) vs P, 250, 0, 1000, 150, -1.5, 1.5);
  DBOOK1D(RPt20_40, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt40_60, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt60_80, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt80_100, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt100_150, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt150_200, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt200_250, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt250_300, #DeltaP_{T} / P_{T}, 80, -1, 1);
  DBOOK1D(RPt300_400, #DeltaP_{T} / P_{T}, 160, -1, 1);
  DBOOK1D(RPt400_500, #DeltaP_{T} / P_{T}, 160, -1, 1);
  DBOOK1D(RPt500_750, #DeltaP_{T} / P_{T}, 160, -1, 1);
  DBOOK1D(RPt750_1250, #DeltaP_{T} / P_{T}, 160, -1, 1);
  DBOOK1D(RPt1250_2000, #DeltaP_{T} / P_{T}, 160, -1, 1);
  DBOOK1D(RPt2000_5000, #DeltaP_{T} / P_{T}, 160, -1, 1);

  DBOOK2D(DEtavsPt, #Delta #eta vs P_{T}, 1000, 0, 2000, 500, -0.5, 0.5);
  DBOOK2D(DPhivsPt, #Delta #phi vs P_{T}, 1000, 0, 2000, 500, -0.5, 0.5);
  BOOK2D(DEtavsEta, "#Delta#eta vs P_{T}", 1000, -5., +5., 500, -0.5, 0.5);
  BOOK2D(DPhivsEta, "#Delta#phi vs P_{T}", 1000, -5., +5., 500, -0.5, 0.5);

  // Set Axis Titles

  // Jets inclusive  distributions  (Pt > 20 GeV)
  SETAXES(Njets, "", "Multiplicity");
  SETAXES(jetsPt, PT, "Number of Events");
  SETAXES(jetsEta, "#eta", "Number of Events");
  SETAXES(RNeutvsEta, "#eta", "#DeltaE/E (Neutral)");
  SETAXES(RNEUTvsEta, "#eta", "#DeltaE/E (ECAL+HCAL)");
  SETAXES(RNONLvsEta, "#eta", "#DeltaE/E (ECAL+HCAL-only)");
  SETAXES(RHCALvsEta, "#eta", "#DeltaE/E (HCAL)");
  SETAXES(RHONLvsEta, "#eta", "#DeltaE/E (HCAL Only)");
  SETAXES(RCHEvsEta, "#eta", "#DeltaE/E (Charged)");
  SETAXES(RPtvsEta, "#eta", "#DeltaP_{T}/P_{T}");
  SETAXES(DEtavsEta, "#eta", "#Delta#eta");
  SETAXES(DPhivsEta, "#eta", "#Delta#phi");
  // delta Pt or E quantities for Barrel and Endcap
  DSETAXES(RPt, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt20_40, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt40_60, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt60_80, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt80_100, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt100_150, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt150_200, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt200_250, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt250_300, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt300_400, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt400_500, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt500_750, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt750_1250, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt1250_2000, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RPt2000_5000, "#DeltaP_{T}/P_{T}", "Events");
  DSETAXES(RCHE, "#DeltaE/E(charged had)", "Events");
  DSETAXES(RNHE, "#DeltaE/E(neutral had)", "Events");
  DSETAXES(RNEE, "#DeltaE/E(neutral em)", "Events");
  DSETAXES(Rneut, "#DeltaE/E(neutral)", "Events");
  DSETAXES(RPtvsPt, PT, "#DeltaP_{T}/P_{T}");
  DSETAXES(RCHEvsPt, PT, "#DeltaE/E(charged had)");
  DSETAXES(RNHEvsPt, PT, "#DeltaE/E(neutral had)");
  DSETAXES(RNEEvsPt, PT, "#DeltaE/E(neutral em)");
  DSETAXES(RneutvsPt, PT, "#DeltaE/E(neutral)");
  DSETAXES(RHCALvsP, P, "#DeltaE/E(HCAL)");
  DSETAXES(RHONLvsP, P, "#DeltaE/E(HCAL-only)");
  DSETAXES(RNEUTvsP, P, "#DeltaE/E(ECAL+HCAL)");
  DSETAXES(RNONLvsP, P, "#DeltaE/E(ECAL+HCAL-only)");
  DSETAXES(DEtavsPt, PT, "#Delta#eta");
  DSETAXES(DPhivsPt, PT, "#Delta#phi");
}

write()

void PFJetBenchmark::write

(

)

Definition at line 54 of file PFJetBenchmark.cc.

References gather_cfg::cout, dbe_, file_, outputFile_, and dqm::implementation::DQMStore::save().

Referenced by PFJetBenchmarkAnalyzer::endJob().

                           {
  // Store the DAQ Histograms
  if (!outputFile_.empty()) {
    if (dbe_)
      dbe_->save(outputFile_);
    // use bare Root if no DQM (FWLite applications)
    else if (file_) {
      file_->Write(outputFile_.c_str());
      cout << "Benchmark output written to file " << outputFile_.c_str() << endl;
      file_->Close();
    }
  } else
    cout << "No output file specified (" << outputFile_ << "). Results will not be saved!" << endl;
}

Member Data Documentation

algo_

PFBenchmarkAlgo* PFJetBenchmark::algo_

protected

Definition at line 215 of file PFJetBenchmark.h.

Referenced by process().

dbe_

DQMStore* PFJetBenchmark::dbe_

protected

Definition at line 227 of file PFJetBenchmark.h.

Referenced by setup(), and write().

debug_

bool PFJetBenchmark::debug_

protected

Definition at line 216 of file PFJetBenchmark.h.

Referenced by process(), and setup().

deltaRMax_

double PFJetBenchmark::deltaRMax_

protected

Definition at line 219 of file PFJetBenchmark.h.

Referenced by process(), and setup().

entry_

unsigned int PFJetBenchmark::entry_

protected

Definition at line 226 of file PFJetBenchmark.h.

Referenced by process().

file_

TFile* PFJetBenchmark::file_

private

Definition at line 60 of file PFJetBenchmark.h.

Referenced by setup(), write(), and ~PFJetBenchmark().

hBDEtavsPt

TH2F* PFJetBenchmark::hBDEtavsPt

private

Definition at line 115 of file PFJetBenchmark.h.

Referenced by process().

hBDPhivsPt

TH2F* PFJetBenchmark::hBDPhivsPt

private

Definition at line 116 of file PFJetBenchmark.h.

Referenced by process().

hBNCH

TH1F* PFJetBenchmark::hBNCH

private

Definition at line 118 of file PFJetBenchmark.h.

Referenced by process().

hBNCH0vsPt

TH2F* PFJetBenchmark::hBNCH0vsPt

private

Definition at line 119 of file PFJetBenchmark.h.

Referenced by process().

hBNCH1vsPt

TH2F* PFJetBenchmark::hBNCH1vsPt

private

Definition at line 120 of file PFJetBenchmark.h.

Referenced by process().

hBNCH2vsPt

TH2F* PFJetBenchmark::hBNCH2vsPt

private

Definition at line 121 of file PFJetBenchmark.h.

Referenced by process().

hBNCH3vsPt

TH2F* PFJetBenchmark::hBNCH3vsPt

private

Definition at line 122 of file PFJetBenchmark.h.

Referenced by process().

hBNCH4vsPt

TH2F* PFJetBenchmark::hBNCH4vsPt

private

Definition at line 123 of file PFJetBenchmark.h.

Referenced by process().

hBNCH5vsPt

TH2F* PFJetBenchmark::hBNCH5vsPt

private

Definition at line 124 of file PFJetBenchmark.h.

Referenced by process().

hBNCH6vsPt

TH2F* PFJetBenchmark::hBNCH6vsPt

private

Definition at line 125 of file PFJetBenchmark.h.

Referenced by process().

hBNCH7vsPt

TH2F* PFJetBenchmark::hBNCH7vsPt

private

Definition at line 126 of file PFJetBenchmark.h.

Referenced by process().

hBNCHvsPt

TH2F* PFJetBenchmark::hBNCHvsPt

private

Definition at line 117 of file PFJetBenchmark.h.

Referenced by process().

hBRCHE

TH1F* PFJetBenchmark::hBRCHE

private

Definition at line 102 of file PFJetBenchmark.h.

Referenced by process().

hBRCHEvsPt

TH2F* PFJetBenchmark::hBRCHEvsPt

private

Definition at line 107 of file PFJetBenchmark.h.

Referenced by process().

hBRHCALvsP

TH2F* PFJetBenchmark::hBRHCALvsP

private

Definition at line 113 of file PFJetBenchmark.h.

Referenced by process().

hBRHONLvsP

TH2F* PFJetBenchmark::hBRHONLvsP

private

Definition at line 114 of file PFJetBenchmark.h.

Referenced by process().

hBRNEE

TH1F* PFJetBenchmark::hBRNEE

private

Definition at line 104 of file PFJetBenchmark.h.

Referenced by process().

hBRNEEvsPt

TH2F* PFJetBenchmark::hBRNEEvsPt

private

Definition at line 109 of file PFJetBenchmark.h.

Referenced by process().

hBRneut

TH1F* PFJetBenchmark::hBRneut

private

Definition at line 105 of file PFJetBenchmark.h.

Referenced by process().

hBRNEUTvsP

TH2F* PFJetBenchmark::hBRNEUTvsP

private

Definition at line 111 of file PFJetBenchmark.h.

Referenced by process().

hBRneutvsPt

TH2F* PFJetBenchmark::hBRneutvsPt

private

Definition at line 110 of file PFJetBenchmark.h.

Referenced by process().

hBRNHE

TH1F* PFJetBenchmark::hBRNHE

private

Definition at line 103 of file PFJetBenchmark.h.

Referenced by process().

hBRNHEvsPt

TH2F* PFJetBenchmark::hBRNHEvsPt

private

Definition at line 108 of file PFJetBenchmark.h.

Referenced by process().

hBRNONLvsP

TH2F* PFJetBenchmark::hBRNONLvsP

private

Definition at line 112 of file PFJetBenchmark.h.

Referenced by process().

hBRPt

TH1F* PFJetBenchmark::hBRPt

private

Definition at line 87 of file PFJetBenchmark.h.

Referenced by process().

hBRPt100_150

TH1F* PFJetBenchmark::hBRPt100_150

private

Definition at line 92 of file PFJetBenchmark.h.

Referenced by process().

hBRPt1250_2000

TH1F* PFJetBenchmark::hBRPt1250_2000

private

Definition at line 100 of file PFJetBenchmark.h.

Referenced by process().

hBRPt150_200

TH1F* PFJetBenchmark::hBRPt150_200

private

Definition at line 93 of file PFJetBenchmark.h.

Referenced by process().

hBRPt2000_5000

TH1F* PFJetBenchmark::hBRPt2000_5000

private

Definition at line 101 of file PFJetBenchmark.h.

Referenced by process().

hBRPt200_250

TH1F* PFJetBenchmark::hBRPt200_250

private

Definition at line 94 of file PFJetBenchmark.h.

Referenced by process().

hBRPt20_40

TH1F* PFJetBenchmark::hBRPt20_40

private

Definition at line 88 of file PFJetBenchmark.h.

Referenced by process().

hBRPt250_300

TH1F* PFJetBenchmark::hBRPt250_300

private

Definition at line 95 of file PFJetBenchmark.h.

Referenced by process().

hBRPt300_400

TH1F* PFJetBenchmark::hBRPt300_400

private

Definition at line 96 of file PFJetBenchmark.h.

Referenced by process().

hBRPt400_500

TH1F* PFJetBenchmark::hBRPt400_500

private

Definition at line 97 of file PFJetBenchmark.h.

Referenced by process().

hBRPt40_60

TH1F* PFJetBenchmark::hBRPt40_60

private

Definition at line 89 of file PFJetBenchmark.h.

Referenced by process().

hBRPt500_750

TH1F* PFJetBenchmark::hBRPt500_750

private

Definition at line 98 of file PFJetBenchmark.h.

Referenced by process().

hBRPt60_80

TH1F* PFJetBenchmark::hBRPt60_80

private

Definition at line 90 of file PFJetBenchmark.h.

Referenced by process().

hBRPt750_1250

TH1F* PFJetBenchmark::hBRPt750_1250

private

Definition at line 99 of file PFJetBenchmark.h.

Referenced by process().

hBRPt80_100

TH1F* PFJetBenchmark::hBRPt80_100

private

Definition at line 91 of file PFJetBenchmark.h.

Referenced by process().

hBRPtvsPt

TH2F* PFJetBenchmark::hBRPtvsPt

private

Definition at line 106 of file PFJetBenchmark.h.

Referenced by process().

hDEtavsEta

TH2F* PFJetBenchmark::hDEtavsEta

private

Definition at line 68 of file PFJetBenchmark.h.

Referenced by process().

hDPhivsEta

TH2F* PFJetBenchmark::hDPhivsEta

private

Definition at line 69 of file PFJetBenchmark.h.

Referenced by process().

hEDEtavsPt

TH2F* PFJetBenchmark::hEDEtavsPt

private

Definition at line 157 of file PFJetBenchmark.h.

Referenced by process().

hEDPhivsPt

TH2F* PFJetBenchmark::hEDPhivsPt

private

Definition at line 158 of file PFJetBenchmark.h.

Referenced by process().

hENCH

TH1F* PFJetBenchmark::hENCH

private

Definition at line 160 of file PFJetBenchmark.h.

Referenced by process().

hENCH0vsPt

TH2F* PFJetBenchmark::hENCH0vsPt

private

Definition at line 161 of file PFJetBenchmark.h.

Referenced by process().

hENCH1vsPt

TH2F* PFJetBenchmark::hENCH1vsPt

private

Definition at line 162 of file PFJetBenchmark.h.

Referenced by process().

hENCH2vsPt

TH2F* PFJetBenchmark::hENCH2vsPt

private

Definition at line 163 of file PFJetBenchmark.h.

Referenced by process().

hENCH3vsPt

TH2F* PFJetBenchmark::hENCH3vsPt

private

Definition at line 164 of file PFJetBenchmark.h.

Referenced by process().

hENCH4vsPt

TH2F* PFJetBenchmark::hENCH4vsPt

private

Definition at line 165 of file PFJetBenchmark.h.

Referenced by process().

hENCH5vsPt

TH2F* PFJetBenchmark::hENCH5vsPt

private

Definition at line 166 of file PFJetBenchmark.h.

Referenced by process().

hENCH6vsPt

TH2F* PFJetBenchmark::hENCH6vsPt

private

Definition at line 167 of file PFJetBenchmark.h.

Referenced by process().

hENCH7vsPt

TH2F* PFJetBenchmark::hENCH7vsPt

private

Definition at line 168 of file PFJetBenchmark.h.

Referenced by process().

hENCHvsPt

TH2F* PFJetBenchmark::hENCHvsPt

private

Definition at line 159 of file PFJetBenchmark.h.

Referenced by process().

hERCHE

TH1F* PFJetBenchmark::hERCHE

private

Definition at line 144 of file PFJetBenchmark.h.

Referenced by process().

hERCHEvsPt

TH2F* PFJetBenchmark::hERCHEvsPt

private

Definition at line 149 of file PFJetBenchmark.h.

Referenced by process().

hERHCALvsP

TH2F* PFJetBenchmark::hERHCALvsP

private

Definition at line 155 of file PFJetBenchmark.h.

Referenced by process().

hERHONLvsP

TH2F* PFJetBenchmark::hERHONLvsP

private

Definition at line 156 of file PFJetBenchmark.h.

Referenced by process().

hERNEE

TH1F* PFJetBenchmark::hERNEE

private

Definition at line 146 of file PFJetBenchmark.h.

Referenced by process().

hERNEEvsPt

TH2F* PFJetBenchmark::hERNEEvsPt

private

Definition at line 151 of file PFJetBenchmark.h.

Referenced by process().

hERneut

TH1F* PFJetBenchmark::hERneut

private

Definition at line 147 of file PFJetBenchmark.h.

Referenced by process().

hERNEUTvsP

TH2F* PFJetBenchmark::hERNEUTvsP

private

Definition at line 153 of file PFJetBenchmark.h.

Referenced by process().

hERneutvsPt

TH2F* PFJetBenchmark::hERneutvsPt

private

Definition at line 152 of file PFJetBenchmark.h.

Referenced by process().

hERNHE

TH1F* PFJetBenchmark::hERNHE

private

Definition at line 145 of file PFJetBenchmark.h.

Referenced by process().

hERNHEvsPt

TH2F* PFJetBenchmark::hERNHEvsPt

private

Definition at line 150 of file PFJetBenchmark.h.

Referenced by process().

hERNONLvsP

TH2F* PFJetBenchmark::hERNONLvsP

private

Definition at line 154 of file PFJetBenchmark.h.

Referenced by process().

hERPt

TH1F* PFJetBenchmark::hERPt

private

Definition at line 129 of file PFJetBenchmark.h.

Referenced by process().

hERPt100_150

TH1F* PFJetBenchmark::hERPt100_150

private

Definition at line 134 of file PFJetBenchmark.h.

Referenced by process().

hERPt1250_2000

TH1F* PFJetBenchmark::hERPt1250_2000

private

Definition at line 142 of file PFJetBenchmark.h.

Referenced by process().

hERPt150_200

TH1F* PFJetBenchmark::hERPt150_200

private

Definition at line 135 of file PFJetBenchmark.h.

Referenced by process().

hERPt2000_5000

TH1F* PFJetBenchmark::hERPt2000_5000

private

Definition at line 143 of file PFJetBenchmark.h.

Referenced by process().

hERPt200_250

TH1F* PFJetBenchmark::hERPt200_250

private

Definition at line 136 of file PFJetBenchmark.h.

Referenced by process().

hERPt20_40

TH1F* PFJetBenchmark::hERPt20_40

private

Definition at line 130 of file PFJetBenchmark.h.

Referenced by process().

hERPt250_300

TH1F* PFJetBenchmark::hERPt250_300

private

Definition at line 137 of file PFJetBenchmark.h.

Referenced by process().

hERPt300_400

TH1F* PFJetBenchmark::hERPt300_400

private

Definition at line 138 of file PFJetBenchmark.h.

Referenced by process().

hERPt400_500

TH1F* PFJetBenchmark::hERPt400_500

private

Definition at line 139 of file PFJetBenchmark.h.

Referenced by process().

hERPt40_60

TH1F* PFJetBenchmark::hERPt40_60

private

Definition at line 131 of file PFJetBenchmark.h.

Referenced by process().

hERPt500_750

TH1F* PFJetBenchmark::hERPt500_750

private

Definition at line 140 of file PFJetBenchmark.h.

Referenced by process().

hERPt60_80

TH1F* PFJetBenchmark::hERPt60_80

private

Definition at line 132 of file PFJetBenchmark.h.

Referenced by process().

hERPt750_1250

TH1F* PFJetBenchmark::hERPt750_1250

private

Definition at line 141 of file PFJetBenchmark.h.

Referenced by process().

hERPt80_100

TH1F* PFJetBenchmark::hERPt80_100

private

Definition at line 133 of file PFJetBenchmark.h.

Referenced by process().

hERPtvsPt

TH2F* PFJetBenchmark::hERPtvsPt

private

Definition at line 148 of file PFJetBenchmark.h.

Referenced by process().

hFDEtavsPt

TH2F* PFJetBenchmark::hFDEtavsPt

private

Definition at line 199 of file PFJetBenchmark.h.

Referenced by process().

hFDPhivsPt

TH2F* PFJetBenchmark::hFDPhivsPt

private

Definition at line 200 of file PFJetBenchmark.h.

Referenced by process().

hFNCH

TH1F* PFJetBenchmark::hFNCH

private

Definition at line 202 of file PFJetBenchmark.h.

hFNCH0vsPt

TH2F* PFJetBenchmark::hFNCH0vsPt

private

Definition at line 203 of file PFJetBenchmark.h.

hFNCH1vsPt

TH2F* PFJetBenchmark::hFNCH1vsPt

private

Definition at line 204 of file PFJetBenchmark.h.

hFNCH2vsPt

TH2F* PFJetBenchmark::hFNCH2vsPt

private

Definition at line 205 of file PFJetBenchmark.h.

hFNCH3vsPt

TH2F* PFJetBenchmark::hFNCH3vsPt

private

Definition at line 206 of file PFJetBenchmark.h.

hFNCH4vsPt

TH2F* PFJetBenchmark::hFNCH4vsPt

private

Definition at line 207 of file PFJetBenchmark.h.

hFNCH5vsPt

TH2F* PFJetBenchmark::hFNCH5vsPt

private

Definition at line 208 of file PFJetBenchmark.h.

hFNCH6vsPt

TH2F* PFJetBenchmark::hFNCH6vsPt

private

Definition at line 209 of file PFJetBenchmark.h.

hFNCH7vsPt

TH2F* PFJetBenchmark::hFNCH7vsPt

private

Definition at line 210 of file PFJetBenchmark.h.

hFNCHvsPt

TH2F* PFJetBenchmark::hFNCHvsPt

private

Definition at line 201 of file PFJetBenchmark.h.

hFRCHE

TH1F* PFJetBenchmark::hFRCHE

private

Definition at line 186 of file PFJetBenchmark.h.

Referenced by process().

hFRCHEvsPt

TH2F* PFJetBenchmark::hFRCHEvsPt

private

Definition at line 191 of file PFJetBenchmark.h.

Referenced by process().

hFRHCALvsP

TH2F* PFJetBenchmark::hFRHCALvsP

private

Definition at line 197 of file PFJetBenchmark.h.

Referenced by process().

hFRHONLvsP

TH2F* PFJetBenchmark::hFRHONLvsP

private

Definition at line 198 of file PFJetBenchmark.h.

Referenced by process().

hFRNEE

TH1F* PFJetBenchmark::hFRNEE

private

Definition at line 188 of file PFJetBenchmark.h.

Referenced by process().

hFRNEEvsPt

TH2F* PFJetBenchmark::hFRNEEvsPt

private

Definition at line 193 of file PFJetBenchmark.h.

Referenced by process().

hFRneut

TH1F* PFJetBenchmark::hFRneut

private

Definition at line 189 of file PFJetBenchmark.h.

Referenced by process().

hFRNEUTvsP

TH2F* PFJetBenchmark::hFRNEUTvsP

private

Definition at line 195 of file PFJetBenchmark.h.

Referenced by process().

hFRneutvsPt

TH2F* PFJetBenchmark::hFRneutvsPt

private

Definition at line 194 of file PFJetBenchmark.h.

Referenced by process().

hFRNHE

TH1F* PFJetBenchmark::hFRNHE

private

Definition at line 187 of file PFJetBenchmark.h.

Referenced by process().

hFRNHEvsPt

TH2F* PFJetBenchmark::hFRNHEvsPt

private

Definition at line 192 of file PFJetBenchmark.h.

Referenced by process().

hFRNONLvsP

TH2F* PFJetBenchmark::hFRNONLvsP

private

Definition at line 196 of file PFJetBenchmark.h.

Referenced by process().

hFRPt

TH1F* PFJetBenchmark::hFRPt

private

Definition at line 171 of file PFJetBenchmark.h.

Referenced by process().

hFRPt100_150

TH1F* PFJetBenchmark::hFRPt100_150

private

Definition at line 176 of file PFJetBenchmark.h.

Referenced by process().

hFRPt1250_2000

TH1F* PFJetBenchmark::hFRPt1250_2000

private

Definition at line 184 of file PFJetBenchmark.h.

Referenced by process().

hFRPt150_200

TH1F* PFJetBenchmark::hFRPt150_200

private

Definition at line 177 of file PFJetBenchmark.h.

Referenced by process().

hFRPt2000_5000

TH1F* PFJetBenchmark::hFRPt2000_5000

private

Definition at line 185 of file PFJetBenchmark.h.

Referenced by process().

hFRPt200_250

TH1F* PFJetBenchmark::hFRPt200_250

private

Definition at line 178 of file PFJetBenchmark.h.

Referenced by process().

hFRPt20_40

TH1F* PFJetBenchmark::hFRPt20_40

private

Definition at line 172 of file PFJetBenchmark.h.

Referenced by process().

hFRPt250_300

TH1F* PFJetBenchmark::hFRPt250_300

private

Definition at line 179 of file PFJetBenchmark.h.

Referenced by process().

hFRPt300_400

TH1F* PFJetBenchmark::hFRPt300_400

private

Definition at line 180 of file PFJetBenchmark.h.

Referenced by process().

hFRPt400_500

TH1F* PFJetBenchmark::hFRPt400_500

private

Definition at line 181 of file PFJetBenchmark.h.

Referenced by process().

hFRPt40_60

TH1F* PFJetBenchmark::hFRPt40_60

private

Definition at line 173 of file PFJetBenchmark.h.

Referenced by process().

hFRPt500_750

TH1F* PFJetBenchmark::hFRPt500_750

private

Definition at line 182 of file PFJetBenchmark.h.

Referenced by process().

hFRPt60_80

TH1F* PFJetBenchmark::hFRPt60_80

private

Definition at line 174 of file PFJetBenchmark.h.

Referenced by process().

hFRPt750_1250

TH1F* PFJetBenchmark::hFRPt750_1250

private

Definition at line 183 of file PFJetBenchmark.h.

Referenced by process().

hFRPt80_100

TH1F* PFJetBenchmark::hFRPt80_100

private

Definition at line 175 of file PFJetBenchmark.h.

Referenced by process().

hFRPtvsPt

TH2F* PFJetBenchmark::hFRPtvsPt

private

Definition at line 190 of file PFJetBenchmark.h.

Referenced by process().

hjetsEta

TH1F* PFJetBenchmark::hjetsEta

private

Definition at line 66 of file PFJetBenchmark.h.

Referenced by process().

hjetsPt

TH1F* PFJetBenchmark::hjetsPt

private

Definition at line 65 of file PFJetBenchmark.h.

Referenced by process().

hNCH0vsEta

TH2F* PFJetBenchmark::hNCH0vsEta

private

Definition at line 77 of file PFJetBenchmark.h.

Referenced by process().

hNCH1vsEta

TH2F* PFJetBenchmark::hNCH1vsEta

private

Definition at line 78 of file PFJetBenchmark.h.

Referenced by process().

hNCH2vsEta

TH2F* PFJetBenchmark::hNCH2vsEta

private

Definition at line 79 of file PFJetBenchmark.h.

Referenced by process().

hNCH3vsEta

TH2F* PFJetBenchmark::hNCH3vsEta

private

Definition at line 80 of file PFJetBenchmark.h.

Referenced by process().

hNCH4vsEta

TH2F* PFJetBenchmark::hNCH4vsEta

private

Definition at line 81 of file PFJetBenchmark.h.

Referenced by process().

hNCH5vsEta

TH2F* PFJetBenchmark::hNCH5vsEta

private

Definition at line 82 of file PFJetBenchmark.h.

Referenced by process().

hNCH6vsEta

TH2F* PFJetBenchmark::hNCH6vsEta

private

Definition at line 83 of file PFJetBenchmark.h.

Referenced by process().

hNCH7vsEta

TH2F* PFJetBenchmark::hNCH7vsEta

private

Definition at line 84 of file PFJetBenchmark.h.

Referenced by process().

hNCHvsEta

TH2F* PFJetBenchmark::hNCHvsEta

private

Definition at line 76 of file PFJetBenchmark.h.

Referenced by process().

hNjets

TH1F* PFJetBenchmark::hNjets

private

Definition at line 64 of file PFJetBenchmark.h.

Referenced by process().

hRCHEvsEta

TH2F* PFJetBenchmark::hRCHEvsEta

private

Definition at line 75 of file PFJetBenchmark.h.

Referenced by process().

hRHCALvsEta

TH2F* PFJetBenchmark::hRHCALvsEta

private

Definition at line 73 of file PFJetBenchmark.h.

Referenced by process().

hRHONLvsEta

TH2F* PFJetBenchmark::hRHONLvsEta

private

Definition at line 74 of file PFJetBenchmark.h.

Referenced by process().

hRNeutvsEta

TH2F* PFJetBenchmark::hRNeutvsEta

private

Definition at line 70 of file PFJetBenchmark.h.

Referenced by process().

hRNEUTvsEta

TH2F* PFJetBenchmark::hRNEUTvsEta

private

Definition at line 71 of file PFJetBenchmark.h.

Referenced by process().

hRNONLvsEta

TH2F* PFJetBenchmark::hRNONLvsEta

private

Definition at line 72 of file PFJetBenchmark.h.

Referenced by process().

hRPtvsEta

TH2F* PFJetBenchmark::hRPtvsEta

private

Definition at line 67 of file PFJetBenchmark.h.

Referenced by process().

maxEta_cut

double PFJetBenchmark::maxEta_cut

protected

Definition at line 225 of file PFJetBenchmark.h.

Referenced by process(), and setup().

onlyTwoJets_

bool PFJetBenchmark::onlyTwoJets_

protected

Definition at line 218 of file PFJetBenchmark.h.

Referenced by process(), and setup().

outputFile_

std::string PFJetBenchmark::outputFile_

private

Definition at line 212 of file PFJetBenchmark.h.

Referenced by setup(), and write().

plotAgainstReco_

bool PFJetBenchmark::plotAgainstReco_

protected

Definition at line 217 of file PFJetBenchmark.h.

Referenced by process(), and setup().

recPt_cut

double PFJetBenchmark::recPt_cut

protected

Definition at line 224 of file PFJetBenchmark.h.

Referenced by process(), and setup().

resChargedHadEnergyMax_

double PFJetBenchmark::resChargedHadEnergyMax_

protected

Definition at line 221 of file PFJetBenchmark.h.

Referenced by process(), and resChargedHadEnergyMax().

resNeutralEmEnergyMax_

double PFJetBenchmark::resNeutralEmEnergyMax_

protected

Definition at line 223 of file PFJetBenchmark.h.

Referenced by process(), and resNeutralEmEnergyMax().

resNeutralHadEnergyMax_

double PFJetBenchmark::resNeutralHadEnergyMax_

protected

Definition at line 222 of file PFJetBenchmark.h.

Referenced by process(), and resNeutralHadEnergyMax().

resPtMax_

double PFJetBenchmark::resPtMax_

protected

Definition at line 220 of file PFJetBenchmark.h.

Referenced by process(), and resPtMax().