Inheritance diagram for PFCandidateAnalyzerDQM:

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

	PFCandidateAnalyzerDQM (const edm::ParameterSet &)

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Protected Member Functions
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Attributes
std::vector< double >	etabins

std::map< std::string, MonitorElement * >	me

std::map< uint32_t, std::string >	pdgMap

edm::InputTag	PFCandTag

edm::EDGetTokenT< edm::View< pat::PackedCandidate > >	PFCandToken

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 35 of file PFCandidateAnalyzerDQM.cc.

Constructor & Destructor Documentation

◆ PFCandidateAnalyzerDQM()

PFCandidateAnalyzerDQM::PFCandidateAnalyzerDQM ( const edm::ParameterSet & iConfig )

explicit

Definition at line 54 of file PFCandidateAnalyzerDQM.cc.

                                                                              {
   PFCandTag = iConfig.getParameter<edm::InputTag>("PFCandType");
   PFCandToken = consumes<edm::View<pat::PackedCandidate>>(PFCandTag);
   etabins = iConfig.getParameter<std::vector<double>>("etabins");
  
   //create map of pdgId
   std::vector<uint32_t> pdgKeys = iConfig.getParameter<std::vector<uint32_t>>("pdgKeys");
   std::vector<std::string> pdgStrs = iConfig.getParameter<std::vector<std::string>>("pdgStrs");
   for (int i = 0, n = pdgKeys.size(); i < n; i++)
     pdgMap[pdgKeys[i]] = pdgStrs[i];
 }

References etabins, edm::ParameterSet::getParameter(), mps_fire::i, dqmiodumpmetadata::n, offsetAnalyzerDQM_cff::pdgKeys, pdgMap, offsetAnalyzerDQM_cff::pdgStrs, PFCandTag, and PFCandToken.

Member Function Documentation

◆ analyze()

void PFCandidateAnalyzerDQM::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 111 of file PFCandidateAnalyzerDQM.cc.

                                                                                         {
   //retrieve
   edm::Handle<edm::View<pat::PackedCandidate>> pfHandle;
   iEvent.getByToken(PFCandToken, pfHandle);
  
   if (!pfHandle.isValid()) {
     edm::LogInfo("OutputInfo") << " failed to retrieve data required by ParticleFlow Task";
     edm::LogInfo("OutputInfo") << " ParticleFlow Task cannot continue...!";
     return;
   } else {
     //Analyze
     // Loop Over Particle Flow Candidates
  
     for (unsigned int i = 0; i < pfHandle->size(); i++) {
       // Fill Histograms for Candidate Methods
       // all candidates
       me["AllCandidateLog10Pt"]->Fill(log10(pfHandle->at(i).pt()));
       me["AllCandidateEta"]->Fill(pfHandle->at(i).eta());
       me["AllCandidatePhi"]->Fill(pfHandle->at(i).phi());
       me["AllCandidateCharge"]->Fill(pfHandle->at(i).charge());
       me["AllCandidatePtLow"]->Fill(pfHandle->at(i).pt());
       me["AllCandidatePtMid"]->Fill(pfHandle->at(i).pt());
       me["AllCandidatePtHigh"]->Fill(pfHandle->at(i).pt());
  
       int pdgId = abs(pfHandle->at(i).pdgId());
       if (pdgMap.find(pdgId) != pdgMap.end()) {
         me[pdgMap[pdgId] + "Log10Pt"]->Fill(log10(pfHandle->at(i).pt()));
         me[pdgMap[pdgId] + "Eta"]->Fill(pfHandle->at(i).eta());
         me[pdgMap[pdgId] + "Phi"]->Fill(pfHandle->at(i).phi());
         me[pdgMap[pdgId] + "Charge"]->Fill(pfHandle->at(i).charge());
         me[pdgMap[pdgId] + "PtLow"]->Fill(pfHandle->at(i).pt());
         me[pdgMap[pdgId] + "PtMid"]->Fill(pfHandle->at(i).pt());
         me[pdgMap[pdgId] + "PtHigh"]->Fill(pfHandle->at(i).pt());
       }
     }
   }
 }

References funct::abs(), mps_fire::i, iEvent, edm::HandleBase::isValid(), me, EgammaValidation_cff::pdgId, pdgMap, and PFCandToken.

◆ bookHistograms()

void PFCandidateAnalyzerDQM::bookHistograms	(	DQMStore::IBooker &	booker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 66 of file PFCandidateAnalyzerDQM.cc.

                                                                                                         {
   // all candidate
   booker.setCurrentFolder("ParticleFlow/PackedCandidates/AllCandidate");
  
   // for eta binning
   int n = etabins.size() - 1;
   float etabinArray[etabins.size()];
   std::copy(etabins.begin(), etabins.end(), etabinArray);
  
   //eta has variable bin sizes, use 4th def of TH1F constructor
   TH1F* etaHist = new TH1F("AllCandidateEta", "AllCandidateEta", n, etabinArray);
   me["AllCandidateEta"] = booker.book1D("AllCandidateEta", etaHist);
  
   me["AllCandidateLog10Pt"] = booker.book1D("AllCandidateLog10Pt", "AllCandidateLog10Pt", 120, -2, 4);
  
   //for phi binnings
   double nPhiBins = 73;
   double phiBinWidth = M_PI / (nPhiBins - 1) * 2.;
   me["AllCandidatePhi"] = booker.book1D(
       "AllCandidatePhi", "AllCandidatePhi", nPhiBins, -M_PI - 0.25 * phiBinWidth, +M_PI + 0.75 * phiBinWidth);
  
   me["AllCandidateCharge"] = booker.book1D("AllCandidateCharge", "AllCandidateCharge", 3, -1.5, 1.5);
   me["AllCandidatePtLow"] = booker.book1D("AllCandidatePtLow", "AllCandidatePtLow", 100, 0., 5.);
   me["AllCandidatePtMid"] = booker.book1D("AllCandidatePtMid", "AllCandidatePtMid", 100, 0., 200.);
   me["AllCandidatePtHigh"] = booker.book1D("AllCandidatePtHigh", "AllCandidatePtHigh", 100, 0., 1000.);
  
   std::string etaHistName;
   for (auto& pair : pdgMap) {
     booker.setCurrentFolder("ParticleFlow/PackedCandidates/" + pair.second);
  
     //TH1F only takes char*, so have to do conversions for histogram name
     etaHistName = pair.second + "Eta";
     TH1F* etaHist = new TH1F(etaHistName.c_str(), etaHistName.c_str(), n, etabinArray);
     me[pair.second + "Eta"] = booker.book1D(pair.second + "Eta", etaHist);
  
     me[pair.second + "Log10Pt"] = booker.book1D(pair.second + "Log10Pt", pair.second + "Log10Pt", 120, -2, 4);
     me[pair.second + "Phi"] = booker.book1D(
         pair.second + "Phi", pair.second + "Phi", nPhiBins, -M_PI - 0.25 * phiBinWidth, +M_PI + 0.75 * phiBinWidth);
     me[pair.second + "Charge"] = booker.book1D(pair.second + "Charge", pair.second + "Charge", 3, -1.5, 1.5);
     me[pair.second + "PtLow"] = booker.book1D(pair.second + "PtLow", pair.second + "PtLow", 100, 0., 5.);
     me[pair.second + "PtMid"] = booker.book1D(pair.second + "PtMid", pair.second + "PtMid", 100, 0., 200.);
     me[pair.second + "PtHigh"] = booker.book1D(pair.second + "PtHigh", pair.second + "PtHigh", 100, 0., 1000.);
   }
 }