#include <PFJetMonitor.h>

Inheritance diagram for PFJetMonitor:

Public Member Functions
template<class T , class C >
void	fill (const T &candidateCollection, const C &matchedCandCollection, float &minVal, float &maxVal, float &jetpT, const edm::ParameterSet &parameterSet)
	fill histograms with all particle More...

void	fillOne (const reco::Jet &jet, const reco::Jet &matchedJet)

	PFJetMonitor (float dRMax=0.3, bool matchCharge=true, Benchmark::Mode mode=Benchmark::DEFAULT)

void	setDirectory (TDirectory *dir) override
	set directory (to use in ROOT) More...

void	setParameters (const edm::ParameterSet &parameterSet)
	set the parameters accessing them from ParameterSet More...

void	setup (DQMStore::IBooker &b)
	book histograms More...

void	setup (DQMStore::IBooker &b, const edm::ParameterSet &parameterSet)

	~PFJetMonitor () override

Public Member Functions inherited from Benchmark
	Benchmark (Mode mode=DEFAULT)

bool	isInRange (float pt, float eta, float phi) const

void	setParameters (Mode mode)

void	setRange (float ptMin, float ptMax, float etaMin, float etaMax, float phiMin, float phiMax)

void	write ()
	write to the TFile, in plain ROOT mode. No need to call this function in DQM mode More...

virtual	~Benchmark () noexcept(false)

Protected Attributes
CandidateBenchmark	candBench_

bool	createPFractionHistos_

TH2F *	delta_frac_VS_frac_charged_hadron_

TH2F *	delta_frac_VS_frac_electron_

TH2F *	delta_frac_VS_frac_muon_

TH2F *	delta_frac_VS_frac_neutral_hadron_

TH2F *	delta_frac_VS_frac_photon_

TH1F *	deltaR_

float	dRMax_

bool	histogramBooked_

MatchCandidateBenchmark	matchCandBench_

bool	matchCharge_

bool	onlyTwoJets_

Protected Attributes inherited from Benchmark
TDirectory *	dir_

float	etaMax_

float	etaMin_

Mode	mode_

float	phiMax_

float	phiMin_

float	ptMax_

float	ptMin_

Additional Inherited Members
Public Types inherited from Benchmark
typedef dqm::legacy::DQMStore	DQMStore

enum	Mode { DEFAULT, DQMOFFLINE, VALIDATION }

Protected Member Functions inherited from Benchmark
TH1F *	book1D (DQMStore::IBooker &b, const char histname, const char title, int nbins, float xmin, float xmax)
	book a 1D histogram, either with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. More...

TH2F *	book2D (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xmin, float xmax, int nbinsy, float ymin, float ymax)
	book a 2D histogram, either with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. More...

TH2F *	book2D (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float *xbins, int nbinsy, float ymin, float ymax)
	book a 2D histogram, either with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. More...

TProfile *	bookProfile (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xmin, float xmax, float ymin, float ymax, const char *option)
	book a TProfile histogram, either with DQM or plain root depending if DQM_ has been initialized in a child analyzer or not. More...

TProfile *	bookProfile (DQMStore::IBooker &b, const char histname, const char title, int nbinsx, float xbins, float ymin, float ymax, const char option)
	book a TProfile, either through IBooker or plain root More...

Detailed Description

Definition at line 17 of file PFJetMonitor.h.

Constructor & Destructor Documentation

PFJetMonitor::PFJetMonitor	(	float	dRMax = `0.3`,
		bool	matchCharge = `true`,
		Benchmark::Mode	mode = `Benchmark::DEFAULT`
	)

Definition at line 15 of file PFJetMonitor.cc.

References createPFractionHistos_, delta_frac_VS_frac_charged_hadron_, delta_frac_VS_frac_electron_, delta_frac_VS_frac_muon_, delta_frac_VS_frac_neutral_hadron_, delta_frac_VS_frac_photon_, deltaR_, histogramBooked_, and Benchmark::setRange().

     : Benchmark(mode), candBench_(mode), matchCandBench_(mode), dRMax_(dRMax), matchCharge_(matchCharge) {
   setRange(0.0, 10e10, -10.0, 10.0, -3.14, 3.14);
 
   delta_frac_VS_frac_muon_ = nullptr;
   delta_frac_VS_frac_photon_ = nullptr;
   delta_frac_VS_frac_electron_ = nullptr;
   delta_frac_VS_frac_charged_hadron_ = nullptr;
   delta_frac_VS_frac_neutral_hadron_ = nullptr;
 
   deltaR_ = nullptr;
 
   createPFractionHistos_ = false;
   histogramBooked_ = false;
 }

PFJetMonitor::~PFJetMonitor ( )

override

Definition at line 34 of file PFJetMonitor.cc.

34 {}

Member Function Documentation

template<class T , class C >

void PFJetMonitor::fill	(	const T &	candidateCollection,
		const C &	matchedCandCollection,
		float &	minVal,
		float &	maxVal,
		float &	jetpT,
		const edm::ParameterSet &	parameterSet
	)

fill histograms with all particle

Definition at line 65 of file PFJetMonitor.h.

References cms::cuda::assert(), SplitLinear::begin, candBench_, createPFractionHistos_, reco::deltaR(), deltaR_, dRMax_, dataset::end, reco::LeafCandidate::eta(), CandidateBenchmark::fillOne(), MatchCandidateBenchmark::fillOne(), fillOne(), histogramBooked_, mps_fire::i, Benchmark::isInRange(), dqmiolumiharvest::j, metsig::jet, PFB::match(), matchCandBench_, matchCharge_, onlyTwoJets_, reco::LeafCandidate::phi(), and reco::LeafCandidate::pt().

Referenced by PFJetDQMAnalyzer::analyze().

                                                              {
   std::vector<int> matchIndices;
   PFB::match(jetCollection, matchedJetCollection, matchIndices, matchCharge_, dRMax_);
   // now matchIndices[i] stores the j-th closest matched jet
 
   std::vector<uint32_t> sorted_pt_indices(jetCollection.size());
   std::iota(std::begin(sorted_pt_indices), std::end(sorted_pt_indices), 0);
   // Sort the vector of indices using the pt() as ordering variable
   std::sort(std::begin(sorted_pt_indices), std::end(sorted_pt_indices), [&](uint32_t i, uint32_t j) {
     return jetCollection[i].pt() < jetCollection[j].pt();
   });
   for (uint32_t i = 0; i < sorted_pt_indices.size(); ++i) {
     // If we want only the 2 pt-leading jets, now that they are orderd, simply
     // check if the index is either in the first or second location of the
     // sorted indices: if not, bail out.
     if (onlyTwoJets_ && i > 1)
       break;
 
     const reco::Jet &jet = jetCollection[i];
 
     if (!isInRange(jet.pt(), jet.eta(), jet.phi()))
       continue;
 
     int iMatch = matchIndices[i];
     assert(iMatch < static_cast<int>(matchedJetCollection.size()));
 
     if (iMatch != -1) {
       const reco::Jet &matchedJet = matchedJetCollection[iMatch];
       if (!isInRange(matchedJet.pt(), matchedJet.eta(), matchedJet.phi()))
         continue;
 
       float ptRes = (jet.pt() - matchedJet.pt()) / matchedJet.pt();
 
       jetpT = jet.pt();
       if (ptRes > maxVal)
         maxVal = ptRes;
       if (ptRes < minVal)
         minVal = ptRes;
 
       candBench_.fillOne(jet);  // fill pt eta phi and charge histos for MATCHED candidate jet
       matchCandBench_.fillOne(jet, matchedJet, parameterSet);  // fill delta_x_VS_y histos for matched couple
       if (createPFractionHistos_ && histogramBooked_)
         fillOne(jet, matchedJet);  // book and fill delta_frac_VS_frac histos for matched couple
     }
 
     for (unsigned j = 0; j < matchedJetCollection.size(); ++j)  // for DeltaR spectrum
       if (deltaR_)
         deltaR_->Fill(reco::deltaR(jetCollection[i], matchedJetCollection[j]));
   }  // end loop on jetCollection
 }

void PFJetMonitor::fillOne	(	const reco::Jet &	jet,
		const reco::Jet &	matchedJet
	)

Definition at line 167 of file PFJetMonitor.cc.

References reco::PFJet::chargedHadronMultiplicity(), createPFractionHistos_, delta_frac_VS_frac_charged_hadron_, delta_frac_VS_frac_electron_, delta_frac_VS_frac_muon_, delta_frac_VS_frac_neutral_hadron_, delta_frac_VS_frac_photon_, reco::PFJet::electronMultiplicity(), metsig::jet, reco::PFJet::muonMultiplicity(), reco::PFJet::neutralHadronMultiplicity(), and reco::PFJet::photonMultiplicity().

Referenced by fill().

                                                                         {
   const reco::PFJet *pfJet = dynamic_cast<const reco::PFJet *>(&jet);
   const reco::PFJet *pfMatchedJet = dynamic_cast<const reco::PFJet *>(&matchedJet);
   if (pfJet && pfMatchedJet && createPFractionHistos_) {
     float del_frac_muon = -99.9;
     float del_frac_elec = -99.9;
     float del_frac_phot = -99.9;
     float del_frac_ch_had = -99.9;
     float del_frac_neu_had = -99.9;
 
     int mult_muon = pfMatchedJet->muonMultiplicity();
     int mult_elec = pfMatchedJet->electronMultiplicity();
     int mult_phot = pfMatchedJet->photonMultiplicity();
     int mult_ch_had = pfMatchedJet->chargedHadronMultiplicity();
     int mult_neu_had = pfMatchedJet->neutralHadronMultiplicity();
 
     if (mult_muon > 0)
       del_frac_muon = (pfJet->muonMultiplicity() - mult_muon) * 1.0 / mult_muon;
     if (mult_elec > 0)
       del_frac_elec = (pfJet->electronMultiplicity() - mult_elec) * 1.0 / mult_elec;
     if (mult_phot > 0)
       del_frac_phot = (pfJet->photonMultiplicity() - mult_phot) * 1.0 / mult_phot;
     if (mult_ch_had > 0)
       del_frac_ch_had = (pfJet->chargedHadronMultiplicity() - mult_ch_had) * 1.0 / mult_ch_had;
     if (mult_neu_had > 0)
       del_frac_neu_had = (pfJet->neutralHadronMultiplicity() - mult_neu_had) * 1.0 / mult_neu_had;
 
     delta_frac_VS_frac_muon_->Fill(mult_muon, del_frac_muon);
     delta_frac_VS_frac_electron_->Fill(mult_elec, del_frac_elec);
     delta_frac_VS_frac_photon_->Fill(mult_phot, del_frac_phot);
     delta_frac_VS_frac_charged_hadron_->Fill(mult_ch_had, del_frac_ch_had);
     delta_frac_VS_frac_neutral_hadron_->Fill(mult_neu_had, del_frac_neu_had);
   }
 }

void PFJetMonitor::setDirectory ( TDirectory * dir )

overridevirtual

set directory (to use in ROOT)

Reimplemented from Benchmark.

Definition at line 157 of file PFJetMonitor.cc.

References candBench_, matchCandBench_, and Benchmark::setDirectory().

                                                {
   Benchmark::setDirectory(dir);
 
   candBench_.setDirectory(dir);
   matchCandBench_.setDirectory(dir);
 }

void PFJetMonitor::setParameters ( const edm::ParameterSet & parameterSet )

set the parameters accessing them from ParameterSet

Definition at line 39 of file PFJetMonitor.cc.

References candBench_, createPFractionHistos_, dRMax_, edm::ParameterSet::getParameter(), matchCandBench_, matchCharge_, Benchmark::mode_, onlyTwoJets_, Benchmark::setParameters(), and Benchmark::setRange().

Referenced by PFJetDQMAnalyzer::PFJetDQMAnalyzer().

                                                                     {
   dRMax_ = parameterSet.getParameter<double>("deltaRMax");
   onlyTwoJets_ = parameterSet.getParameter<bool>("onlyTwoJets");
   matchCharge_ = parameterSet.getParameter<bool>("matchCharge");
   mode_ = (Benchmark::Mode)parameterSet.getParameter<int>("mode");
   createPFractionHistos_ = parameterSet.getParameter<bool>("CreatePFractionHistos");
 
   setRange(parameterSet.getParameter<double>("ptMin"),
            parameterSet.getParameter<double>("ptMax"),
            parameterSet.getParameter<double>("etaMin"),
            parameterSet.getParameter<double>("etaMax"),
            parameterSet.getParameter<double>("phiMin"),
            parameterSet.getParameter<double>("phiMax"));
 
   candBench_.setParameters(mode_);
   candBench_.setRange(parameterSet.getParameter<double>("ptMin"),
                       parameterSet.getParameter<double>("ptMax"),
                       parameterSet.getParameter<double>("etaMin"),
                       parameterSet.getParameter<double>("etaMax"),
                       parameterSet.getParameter<double>("phiMin"),
                       parameterSet.getParameter<double>("phiMax"));
 
   matchCandBench_.setParameters(mode_);
   matchCandBench_.setRange(parameterSet.getParameter<double>("ptMin"),
                            parameterSet.getParameter<double>("ptMax"),
                            parameterSet.getParameter<double>("etaMin"),
                            parameterSet.getParameter<double>("etaMax"),
                            parameterSet.getParameter<double>("phiMin"),
                            parameterSet.getParameter<double>("phiMax"));
 }

void PFJetMonitor::setup ( DQMStore::IBooker & b )

book histograms

Definition at line 119 of file PFJetMonitor.cc.

References Benchmark::book2D(), candBench_, createPFractionHistos_, delta_frac_VS_frac_charged_hadron_, delta_frac_VS_frac_electron_, delta_frac_VS_frac_muon_, delta_frac_VS_frac_neutral_hadron_, delta_frac_VS_frac_photon_, histogramBooked_, matchCandBench_, CandidateBenchmark::setup(), and MatchCandidateBenchmark::setup().

Referenced by PFJetDQMAnalyzer::bookHistograms().

                                            {
   candBench_.setup(b);
   matchCandBench_.setup(b);
 
   if (createPFractionHistos_ && !histogramBooked_) {
     delta_frac_VS_frac_muon_ =
         book2D(b, "delta_frac_VS_frac_muon_", "#DeltaFraction_Vs_Fraction(muon)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_photon_ =
         book2D(b, "delta_frac_VS_frac_photon_", "#DeltaFraction_Vs_Fraction(photon)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_electron_ = book2D(
         b, "delta_frac_VS_frac_electron_", "#DeltaFraction_Vs_Fraction(electron)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_charged_hadron_ = book2D(b,
                                                 "delta_frac_VS_frac_charged_hadron_",
                                                 "#DeltaFraction_Vs_Fraction(charged hadron)",
                                                 100,
                                                 0.0,
                                                 1.0,
                                                 100,
                                                 -1.0,
                                                 1.0);
     delta_frac_VS_frac_neutral_hadron_ = book2D(b,
                                                 "delta_frac_VS_frac_neutral_hadron_",
                                                 "#DeltaFraction_Vs_Fraction(neutral hadron)",
                                                 100,
                                                 0.0,
                                                 1.0,
                                                 100,
                                                 -1.0,
                                                 1.0);
 
     histogramBooked_ = true;
   }
 }

void PFJetMonitor::setup	(	DQMStore::IBooker &	b,
		const edm::ParameterSet &	parameterSet
	)

Definition at line 73 of file PFJetMonitor.cc.

References Benchmark::book1D(), Benchmark::book2D(), candBench_, createPFractionHistos_, delta_frac_VS_frac_charged_hadron_, delta_frac_VS_frac_electron_, delta_frac_VS_frac_muon_, delta_frac_VS_frac_neutral_hadron_, delta_frac_VS_frac_photon_, deltaR_, edm::ParameterSet::getParameter(), histogramBooked_, matchCandBench_, CandidateBenchmark::setup(), and MatchCandidateBenchmark::setup().

                                                                                 {
   candBench_.setup(b, parameterSet);
   matchCandBench_.setup(b, parameterSet);
 
   edm::ParameterSet dR = parameterSet.getParameter<edm::ParameterSet>("DeltaRHistoParameter");
   if (dR.getParameter<bool>("switchOn")) {
     deltaR_ = book1D(b,
                      "deltaR_",
                      "#DeltaR;#DeltaR",
                      dR.getParameter<int32_t>("nBin"),
                      dR.getParameter<double>("xMin"),
                      dR.getParameter<double>("xMax"));
   }
   if (createPFractionHistos_ && !histogramBooked_) {
     delta_frac_VS_frac_muon_ =
         book2D(b, "delta_frac_VS_frac_muon_", "#DeltaFraction_Vs_Fraction(muon)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_photon_ =
         book2D(b, "delta_frac_VS_frac_photon_", "#DeltaFraction_Vs_Fraction(photon)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_electron_ = book2D(
         b, "delta_frac_VS_frac_electron_", "#DeltaFraction_Vs_Fraction(electron)", 100, 0.0, 1.0, 100, -1.0, 1.0);
     delta_frac_VS_frac_charged_hadron_ = book2D(b,
                                                 "delta_frac_VS_frac_charged_hadron_",
                                                 "#DeltaFraction_Vs_Fraction(charged hadron)",
                                                 100,
                                                 0.0,
                                                 1.0,
                                                 100,
                                                 -1.0,
                                                 1.0);
     delta_frac_VS_frac_neutral_hadron_ = book2D(b,
                                                 "delta_frac_VS_frac_neutral_hadron_",
                                                 "#DeltaFraction_Vs_Fraction(neutral hadron)",
                                                 100,
                                                 0.0,
                                                 1.0,
                                                 100,
                                                 -1.0,
                                                 1.0);
 
     histogramBooked_ = true;
   }
 }