#include <JetAnalyzer_HeavyIons.h>

Inheritance diagram for JetAnalyzer_HeavyIons:

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

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

	JetAnalyzer_HeavyIons (const edm::ParameterSet &)

	~JetAnalyzer_HeavyIons () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
edm::InputTag	Background

edm::EDGetTokenT< reco::BasicJetCollection >	basicJetsToken_

edm::EDGetTokenT< reco::CandidateView >	caloCandViewToken_

edm::EDGetTokenT< reco::CaloJetCollection >	caloJetsToken_

edm::EDGetTokenT< CaloTowerCollection >	caloTowersToken_

edm::Handle< reco::Centrality >	centrality_

edm::Handle< int >	centralityBin_

edm::InputTag	centralityBinTag_

edm::EDGetTokenT< int >	centralityBinToken

edm::InputTag	centralityTag_

edm::EDGetTokenT< reco::Centrality >	centralityToken

edm::EDGetTokenT< reco::PFCandidateCollection >	csCandToken_

const double	edge_pseudorapidity [etaBins_+1] = {-5, -3, -2.1, -1.3, 1.3, 2.1, 3, 5}

edm::EDGetTokenT< std::vector< double > >	etaToken_

edm::EDGetTokenT< std::vector< reco::Vertex > >	hiVertexToken_

bool	isCaloJet

bool	isJPTJet

bool	isPFJet

std::string	JetCorrectionService

std::string	JetType

edm::EDGetTokenT< reco::JPTJetCollection >	jptJetsToken_

MonitorElement *	mCaloArea

MonitorElement *	mCaloEta

MonitorElement *	mCaloPhi

MonitorElement *	mCaloPt

MonitorElement *	mConstituents

MonitorElement *	mCSCand_corrPFcand [etaBins_]

MonitorElement *	mCSCandpT_vsPt [etaBins_]

MonitorElement *	mEnergy

MonitorElement *	mEta

MonitorElement *	mHF

edm::InputTag	mInputCollection

edm::InputTag	mInputCsCandCollection

edm::InputTag	mInputPFCandCollection

edm::InputTag	mInputVtxCollection

MonitorElement *	mJetArea

MonitorElement *	mjetpileup

MonitorElement *	mMass

MonitorElement *	mNCalopart

MonitorElement *	mNJets

MonitorElement *	mNJets_40

MonitorElement *	mNPFpart

MonitorElement *	mNvtx

std::string	mOutputFile

MonitorElement *	mP

MonitorElement *	mPFArea

MonitorElement *	mPFCandpT_Barrel_ChargedHadron

MonitorElement *	mPFCandpT_Barrel_electron

MonitorElement *	mPFCandpT_Barrel_EME_inHF

MonitorElement *	mPFCandpT_Barrel_HadE_inHF

MonitorElement *	mPFCandpT_Barrel_muon

MonitorElement *	mPFCandpT_Barrel_NeutralHadron

MonitorElement *	mPFCandpT_Barrel_photon

MonitorElement *	mPFCandpT_Barrel_Unknown

MonitorElement *	mPFCandpT_Endcap_ChargedHadron

MonitorElement *	mPFCandpT_Endcap_electron

MonitorElement *	mPFCandpT_Endcap_EME_inHF

MonitorElement *	mPFCandpT_Endcap_HadE_inHF

MonitorElement *	mPFCandpT_Endcap_muon

MonitorElement *	mPFCandpT_Endcap_NeutralHadron

MonitorElement *	mPFCandpT_Endcap_photon

MonitorElement *	mPFCandpT_Endcap_Unknown

MonitorElement *	mPFCandpT_Forward_ChargedHadron

MonitorElement *	mPFCandpT_Forward_electron

MonitorElement *	mPFCandpT_Forward_EME_inHF

MonitorElement *	mPFCandpT_Forward_HadE_inHF

MonitorElement *	mPFCandpT_Forward_muon

MonitorElement *	mPFCandpT_Forward_NeutralHadron

MonitorElement *	mPFCandpT_Forward_photon

MonitorElement *	mPFCandpT_Forward_Unknown

MonitorElement *	mPFCandpT_vs_eta_ChargedHadron

MonitorElement *	mPFCandpT_vs_eta_electron

MonitorElement *	mPFCandpT_vs_eta_EME_inHF

MonitorElement *	mPFCandpT_vs_eta_HadE_inHF

MonitorElement *	mPFCandpT_vs_eta_muon

MonitorElement *	mPFCandpT_vs_eta_NeutralHadron

MonitorElement *	mPFCandpT_vs_eta_photon

MonitorElement *	mPFCandpT_vs_eta_Unknown

MonitorElement *	mPFDeltaR

MonitorElement *	mPFDeltaR_Scaled_R

MonitorElement *	mPFEta

MonitorElement *	mPFPhi

MonitorElement *	mPFPt

MonitorElement *	mPhi

MonitorElement *	mPt

double	mRecoJetPtThreshold

double	mReverseEnergyFractionThreshold

MonitorElement *	mRhoDist_vsCent [etaBins_]

MonitorElement *	mRhoDist_vsEta

MonitorElement *	mRhoDist_vsPt

MonitorElement *	mRhoMDist_vsCent [etaBins_]

MonitorElement *	mRhoMDist_vsEta

MonitorElement *	mRhoMDist_vsPt

double	mRThreshold

MonitorElement *	mSubtractedE [ptBins_][etaBins_]

MonitorElement *	mSubtractedEFrac [ptBins_][etaBins_]

MonitorElement *	mSumCaloPt

MonitorElement *	mSumCaloPt_eta

MonitorElement *	mSumCaloPt_HF

MonitorElement *	mSumCaloPtEtaDep [etaBins_]

MonitorElement *	mSumPFPt

MonitorElement *	mSumPFPt_eta

MonitorElement *	mSumPFPt_HF

MonitorElement *	mSumPFPtEtaDep [etaBins_]

MonitorElement *	mSumpt

MonitorElement *	mSumSquaredCaloPt

MonitorElement *	mSumSquaredCaloPt_eta

MonitorElement *	mSumSquaredPFPt

MonitorElement *	mSumSquaredPFPt_eta

edm::EDGetTokenT< reco::PFCandidateCollection >	pfCandToken_

edm::EDGetTokenT< reco::CandidateView >	pfCandViewToken_

edm::EDGetTokenT< reco::PFJetCollection >	pfJetsToken_

const int	ptBin [ptBins_+1] = {0, 20, 40, 60, 100, 150, 300, 99999}

edm::EDGetTokenT< std::vector< reco::Vertex > >	pvToken_

MonitorElement *	rhoEtaRange

edm::EDGetTokenT< std::vector< double > >	rhomToken_

edm::EDGetTokenT< std::vector< double > >	rhoToken_

std::string	UEAlgo

Static Private Attributes
static constexpr int	etaBins_ = 7

static constexpr int	fourierOrder_ = 5

static constexpr int	nedge_pseudorapidity = etaBins_ + 1

static constexpr int	ptBins_ = 7

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 >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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 Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 74 of file JetAnalyzer_HeavyIons.h.

Constructor & Destructor Documentation

◆ JetAnalyzer_HeavyIons()

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

explicit

Definition at line 17 of file JetAnalyzer_HeavyIons.cc.

References basicJetsToken_, caloCandViewToken_, caloJetsToken_, caloTowersToken_, centralityBinToken, centralityTag_, centralityToken, csCandToken_, etaBins_, etaToken_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hiVertexToken_, hcalRecHitTable_cff::ieta, ProducerED_cfi::InputTag, isCaloJet, isJPTJet, isPFJet, JetType, jptJetsToken_, edm::InputTag::label(), mCaloEta, mCaloPhi, mCaloPt, mConstituents, mCSCandpT_vsPt, mEnergy, mEta, mHF, mInputCollection, mInputCsCandCollection, mInputPFCandCollection, mInputVtxCollection, mJetArea, mjetpileup, mMass, mNCalopart, mNJets, mNJets_40, mNPFpart, mNvtx, mP, mPFCandpT_Barrel_ChargedHadron, mPFCandpT_Barrel_electron, mPFCandpT_Barrel_EME_inHF, mPFCandpT_Barrel_HadE_inHF, mPFCandpT_Barrel_muon, mPFCandpT_Barrel_NeutralHadron, mPFCandpT_Barrel_photon, mPFCandpT_Barrel_Unknown, mPFCandpT_Endcap_ChargedHadron, mPFCandpT_Endcap_electron, mPFCandpT_Endcap_EME_inHF, mPFCandpT_Endcap_HadE_inHF, mPFCandpT_Endcap_muon, mPFCandpT_Endcap_NeutralHadron, mPFCandpT_Endcap_photon, mPFCandpT_Endcap_Unknown, mPFCandpT_Forward_ChargedHadron, mPFCandpT_Forward_electron, mPFCandpT_Forward_EME_inHF, mPFCandpT_Forward_HadE_inHF, mPFCandpT_Forward_muon, mPFCandpT_Forward_NeutralHadron, mPFCandpT_Forward_photon, mPFCandpT_Forward_Unknown, mPFCandpT_vs_eta_ChargedHadron, mPFCandpT_vs_eta_electron, mPFCandpT_vs_eta_EME_inHF, mPFCandpT_vs_eta_HadE_inHF, mPFCandpT_vs_eta_muon, mPFCandpT_vs_eta_NeutralHadron, mPFCandpT_vs_eta_photon, mPFCandpT_vs_eta_Unknown, mPFDeltaR, mPFDeltaR_Scaled_R, mPFEta, mPFPhi, mPFPt, mPhi, mPt, mRhoDist_vsCent, mRhoDist_vsEta, mRhoDist_vsPt, mRhoMDist_vsCent, mRhoMDist_vsEta, mRhoMDist_vsPt, mSubtractedE, mSubtractedEFrac, mSumCaloPt, mSumCaloPt_eta, mSumCaloPt_HF, mSumCaloPtEtaDep, mSumPFPt, mSumPFPt_eta, mSumPFPt_HF, mSumPFPtEtaDep, mSumpt, mSumSquaredCaloPt, mSumSquaredCaloPt_eta, mSumSquaredPFPt, mSumSquaredPFPt_eta, pfCandToken_, pfCandViewToken_, pfJetsToken_, ptBins_, pvToken_, rhoEtaRange, rhomToken_, rhoToken_, AlCaHLTBitMon_QueryRunRegistry::string, and UEAlgo.

     : mInputCollection(iConfig.getParameter<edm::InputTag>("src")),
       mInputVtxCollection(iConfig.getUntrackedParameter<edm::InputTag>("srcVtx", edm::InputTag("hiSelectedVertex"))),
       mInputPFCandCollection(iConfig.getParameter<edm::InputTag>("PFcands")),
       mInputCsCandCollection(iConfig.exists("CScands") ? iConfig.getParameter<edm::InputTag>("CScands")
                                                        : edm::InputTag()),
       mOutputFile(iConfig.getUntrackedParameter<std::string>("OutputFile", "")),
       JetType(iConfig.getUntrackedParameter<std::string>("JetType")),
       UEAlgo(iConfig.getUntrackedParameter<std::string>("UEAlgo")),
       mRecoJetPtThreshold(iConfig.getParameter<double>("recoJetPtThreshold")),
       mReverseEnergyFractionThreshold(iConfig.getParameter<double>("reverseEnergyFractionThreshold")),
       mRThreshold(iConfig.getParameter<double>("RThreshold")),
       JetCorrectionService(iConfig.getParameter<std::string>("JetCorrections")) {
   std::string inputCollectionLabel(mInputCollection.label());
 
   isCaloJet = (std::string("calo") == JetType);
   isJPTJet = (std::string("jpt") == JetType);
   isPFJet = (std::string("pf") == JetType);
 
   //consumes
   pvToken_ = consumes<std::vector<reco::Vertex>>(edm::InputTag("offlinePrimaryVertices"));
   caloTowersToken_ = consumes<CaloTowerCollection>(edm::InputTag("towerMaker"));
   if (isCaloJet)
     caloJetsToken_ = consumes<reco::CaloJetCollection>(mInputCollection);
   if (isJPTJet)
     jptJetsToken_ = consumes<reco::JPTJetCollection>(mInputCollection);
   if (isPFJet) {
     if (std::string("Pu") == UEAlgo)
       basicJetsToken_ = consumes<reco::BasicJetCollection>(mInputCollection);
     if (std::string("Cs") == UEAlgo)
       pfJetsToken_ = consumes<reco::PFJetCollection>(mInputCollection);
   }
 
   pfCandToken_ = consumes<reco::PFCandidateCollection>(mInputPFCandCollection);
   csCandToken_ = mayConsume<reco::PFCandidateCollection>(mInputCsCandCollection);
   pfCandViewToken_ = consumes<reco::CandidateView>(mInputPFCandCollection);
   caloCandViewToken_ = consumes<reco::CandidateView>(edm::InputTag("towerMaker"));
 
   centralityTag_ = iConfig.getParameter<InputTag>("centralitycollection");
   centralityToken = consumes<reco::Centrality>(centralityTag_);
 
   centralityBinToken = mayConsume<int>(iConfig.exists("centralitybincollection")
                                            ? iConfig.getParameter<edm::InputTag>("centralitybincollection")
                                            : edm::InputTag());
 
   hiVertexToken_ = consumes<std::vector<reco::Vertex>>(mInputVtxCollection);
 
   etaToken_ = mayConsume<std::vector<double>>(iConfig.exists("etaMap") ? iConfig.getParameter<edm::InputTag>("etaMap")
                                                                        : edm::InputTag());
   rhoToken_ = mayConsume<std::vector<double>>(iConfig.exists("rho") ? iConfig.getParameter<edm::InputTag>("rho")
                                                                     : edm::InputTag());
   rhomToken_ = mayConsume<std::vector<double>>(iConfig.exists("rhom") ? iConfig.getParameter<edm::InputTag>("rhom")
                                                                       : edm::InputTag());
 
   // need to initialize the PF cand histograms : which are also event variables
   if (isPFJet) {
     mNPFpart = nullptr;
     mPFPt = nullptr;
     mPFEta = nullptr;
     mPFPhi = nullptr;
 
     mSumPFPt = nullptr;
     mSumPFPt_eta = nullptr;
     mSumSquaredPFPt = nullptr;
     mSumSquaredPFPt_eta = nullptr;
     mSumPFPt_HF = nullptr;
 
     mPFDeltaR = nullptr;
     mPFDeltaR_Scaled_R = nullptr;
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       mSumPFPtEtaDep[ieta] = nullptr;
     }
 
     //cs-specific histograms
     mRhoDist_vsEta = nullptr;
     mRhoMDist_vsEta = nullptr;
     mRhoDist_vsPt = nullptr;
     mRhoMDist_vsPt = nullptr;
 
     rhoEtaRange = nullptr;
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       mCSCandpT_vsPt[ieta] = nullptr;
       mRhoDist_vsCent[ieta] = nullptr;
       mRhoMDist_vsCent[ieta] = nullptr;
       for (int ipt = 0; ipt < ptBins_; ipt++) {
         mSubtractedEFrac[ipt][ieta] = nullptr;
         mSubtractedE[ipt][ieta] = nullptr;
       }
     }
 
     mPFCandpT_vs_eta_Unknown = nullptr;        // pf id 0
     mPFCandpT_vs_eta_ChargedHadron = nullptr;  // pf id - 1
     mPFCandpT_vs_eta_electron = nullptr;       // pf id - 2
     mPFCandpT_vs_eta_muon = nullptr;           // pf id - 3
     mPFCandpT_vs_eta_photon = nullptr;         // pf id - 4
     mPFCandpT_vs_eta_NeutralHadron = nullptr;  // pf id - 5
     mPFCandpT_vs_eta_HadE_inHF = nullptr;      // pf id - 6
     mPFCandpT_vs_eta_EME_inHF = nullptr;       // pf id - 7
 
     mPFCandpT_Barrel_Unknown = nullptr;        // pf id 0
     mPFCandpT_Barrel_ChargedHadron = nullptr;  // pf id - 1
     mPFCandpT_Barrel_electron = nullptr;       // pf id - 2
     mPFCandpT_Barrel_muon = nullptr;           // pf id - 3
     mPFCandpT_Barrel_photon = nullptr;         // pf id - 4
     mPFCandpT_Barrel_NeutralHadron = nullptr;  // pf id - 5
     mPFCandpT_Barrel_HadE_inHF = nullptr;      // pf id - 6
     mPFCandpT_Barrel_EME_inHF = nullptr;       // pf id - 7
 
     mPFCandpT_Endcap_Unknown = nullptr;        // pf id 0
     mPFCandpT_Endcap_ChargedHadron = nullptr;  // pf id - 1
     mPFCandpT_Endcap_electron = nullptr;       // pf id - 2
     mPFCandpT_Endcap_muon = nullptr;           // pf id - 3
     mPFCandpT_Endcap_photon = nullptr;         // pf id - 4
     mPFCandpT_Endcap_NeutralHadron = nullptr;  // pf id - 5
     mPFCandpT_Endcap_HadE_inHF = nullptr;      // pf id - 6
     mPFCandpT_Endcap_EME_inHF = nullptr;       // pf id - 7
 
     mPFCandpT_Forward_Unknown = nullptr;        // pf id 0
     mPFCandpT_Forward_ChargedHadron = nullptr;  // pf id - 1
     mPFCandpT_Forward_electron = nullptr;       // pf id - 2
     mPFCandpT_Forward_muon = nullptr;           // pf id - 3
     mPFCandpT_Forward_photon = nullptr;         // pf id - 4
     mPFCandpT_Forward_NeutralHadron = nullptr;  // pf id - 5
     mPFCandpT_Forward_HadE_inHF = nullptr;      // pf id - 6
     mPFCandpT_Forward_EME_inHF = nullptr;       // pf id - 7
   }
   if (isCaloJet) {
     mNCalopart = nullptr;
     mCaloPt = nullptr;
     mCaloEta = nullptr;
     mCaloPhi = nullptr;
 
     mSumCaloPt = nullptr;
     mSumCaloPt_eta = nullptr;
     mSumSquaredCaloPt = nullptr;
     mSumSquaredCaloPt_eta = nullptr;
     mSumCaloPt_HF = nullptr;
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       mSumCaloPtEtaDep[ieta] = nullptr;
     }
   }
 
   mSumpt = nullptr;
 
   // Events variables
   mNvtx = nullptr;
   mHF = nullptr;
 
   // added Jan 12th 2015
 
   // Jet parameters
   mEta = nullptr;
   mPhi = nullptr;
   mEnergy = nullptr;
   mP = nullptr;
   mPt = nullptr;
   mMass = nullptr;
   mConstituents = nullptr;
   mJetArea = nullptr;
   mjetpileup = nullptr;
   mNJets_40 = nullptr;
   mNJets = nullptr;
 }

◆ ~JetAnalyzer_HeavyIons()

JetAnalyzer_HeavyIons::~JetAnalyzer_HeavyIons ( )

override

Definition at line 536 of file JetAnalyzer_HeavyIons.cc.

536 {}

Member Function Documentation

◆ analyze()

void JetAnalyzer_HeavyIons::analyze	(	const edm::Event &	mEvent,
		const edm::EventSetup &	mSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 541 of file JetAnalyzer_HeavyIons.cc.

References cms::cuda::assert(), BarrelEta, basicJetsToken_, caloCandViewToken_, isolatedTracks_cfi::caloJets, caloJetsToken_, caloTowersToken_, centralityToken, csCandToken_, edge_pseudorapidity, EndcapEta, hcalRecHitTable_cff::energy, PVValHelper::eta, reco::LeafCandidate::eta(), etaBins_, bTagCommon_cff::etaRanges, etaToken_, reco::Centrality::EtHFtowerSum(), dqm::impl::MonitorElement::Fill(), ForwardEta, dqm::impl::MonitorElement::getNbinsX(), dqm::impl::MonitorElement::getTH2F(), hiVertexToken_, mps_fire::i, hcalRecHitTable_cff::ieta, createfilelist::int, PixelPluginsPhase0_cfi::isBarrel, isCaloJet, GeomDetEnumerators::isEndcap(), ecaldqm::isForward(), isJPTJet, isPFJet, edm::HandleBase::isValid(), jptJetsToken_, dqmdumpme::k, EgHLTOffHistBins_cfi::mass, mCaloEta, mCaloPhi, mCaloPt, mConstituents, mCSCand_corrPFcand, mCSCandpT_vsPt, mEnergy, mEta, evf::FastMonState::mEvent, mHF, mJetArea, mjetpileup, mMass, mNCalopart, mNJets, mNJets_40, mNPFpart, mNvtx, mP, mPFCandpT_Barrel_ChargedHadron, mPFCandpT_Barrel_electron, mPFCandpT_Barrel_EME_inHF, mPFCandpT_Barrel_HadE_inHF, mPFCandpT_Barrel_muon, mPFCandpT_Barrel_NeutralHadron, mPFCandpT_Barrel_photon, mPFCandpT_Barrel_Unknown, mPFCandpT_Endcap_ChargedHadron, mPFCandpT_Endcap_electron, mPFCandpT_Endcap_EME_inHF, mPFCandpT_Endcap_HadE_inHF, mPFCandpT_Endcap_muon, mPFCandpT_Endcap_NeutralHadron, mPFCandpT_Endcap_photon, mPFCandpT_Endcap_Unknown, mPFCandpT_Forward_ChargedHadron, mPFCandpT_Forward_electron, mPFCandpT_Forward_EME_inHF, mPFCandpT_Forward_HadE_inHF, mPFCandpT_Forward_muon, mPFCandpT_Forward_NeutralHadron, mPFCandpT_Forward_photon, mPFCandpT_Forward_Unknown, mPFCandpT_vs_eta_ChargedHadron, mPFCandpT_vs_eta_electron, mPFCandpT_vs_eta_EME_inHF, mPFCandpT_vs_eta_HadE_inHF, mPFCandpT_vs_eta_muon, mPFCandpT_vs_eta_NeutralHadron, mPFCandpT_vs_eta_photon, mPFCandpT_vs_eta_Unknown, mPFDeltaR, mPFDeltaR_Scaled_R, mPFEta, mPFPhi, mPFPt, mPhi, mPt, mRecoJetPtThreshold, mRhoDist_vsCent, mRhoDist_vsEta, mRhoDist_vsPt, mRhoMDist_vsCent, mRhoMDist_vsEta, mRhoMDist_vsPt, mSubtractedE, mSubtractedEFrac, mSumCaloPt, mSumCaloPt_eta, mSumCaloPt_HF, mSumCaloPtEtaDep, mSumPFPt, mSumPFPt_eta, mSumPFPt_HF, mSumPFPtEtaDep, mSumpt, mSumSquaredCaloPt, mSumSquaredCaloPt_eta, mSumSquaredPFPt, mSumSquaredPFPt_eta, custom_jme_cff::nConstituents, nedge_pseudorapidity, L1TEGammaOffline_cfi::nVertex, AlCaHLTBitMon_ParallelJobs::p, reco::PFCandidate::particleId(), zmumugammaAnalyzer_cfi::pfCandidates, pfCandToken_, pfCandViewToken_, pfJetBenchmark_cfi::pfJets, pfJetsToken_, phi, reco::LeafCandidate::phi(), mixOne_premix_on_sim_cfi::pileup, position, funct::pow(), edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, reco::LeafCandidate::pt(), ptBin, ptBins_, pvToken_, RecoJets_cff::recoJets, rho, jetAnalyzer_cfi::rhom, rhomToken_, rhoToken_, edm::SortedCollection< T, SORT >::size(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, l1tHGCalTowerProducer_cfi::tower, run3scouting_cff::tracksSize, UEAlgo, L1BJetProducer_cff::vtx, and z.

                                                                                        {
   // switch(mEvent.id().event() == 15296770)
   // case 1:
   //   break;
 
   // Get the primary vertices
   edm::Handle<vector<reco::Vertex>> pvHandle;
   mEvent.getByToken(pvToken_, pvHandle);
   reco::Vertex::Point vtx(0, 0, 0);
   edm::Handle<reco::VertexCollection> vtxs;
 
   mEvent.getByToken(hiVertexToken_, vtxs);
   int greatestvtx = 0;
   int nVertex = vtxs->size();
 
   for (unsigned int i = 0; i < vtxs->size(); ++i) {
     unsigned int daughter = (*vtxs)[i].tracksSize();
     if (daughter > (*vtxs)[greatestvtx].tracksSize())
       greatestvtx = i;
   }
 
   if (nVertex <= 0) {
     vtx = reco::Vertex::Point(0, 0, 0);
   }
   vtx = (*vtxs)[greatestvtx].position();
 
   int nGoodVertices = 0;
 
   if (pvHandle.isValid()) {
     for (unsigned i = 0; i < pvHandle->size(); i++) {
       if ((*pvHandle)[i].ndof() > 4 && (fabs((*pvHandle)[i].z()) <= 24) && (fabs((*pvHandle)[i].position().rho()) <= 2))
         nGoodVertices++;
     }
   }
 
   mNvtx->Fill(nGoodVertices);
 
   // Get the Jet collection
   //----------------------------------------------------------------------------
 
   std::vector<Jet> recoJets;
   recoJets.clear();
 
   edm::Handle<CaloJetCollection> caloJets;
   edm::Handle<JPTJetCollection> jptJets;
   edm::Handle<PFJetCollection> pfJets;
   edm::Handle<BasicJetCollection> basicJets;
 
   // Get the Particle flow candidates and the Voronoi variables
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   edm::Handle<reco::PFCandidateCollection> csCandidates;
   edm::Handle<CaloTowerCollection> caloCandidates;
   edm::Handle<reco::CandidateView> pfcandidates_;
   edm::Handle<reco::CandidateView> calocandidates_;
 
   //Get the new CS stuff
   edm::Handle<std::vector<double>> etaRanges;
   edm::Handle<std::vector<double>> rho;
   edm::Handle<std::vector<double>> rhom;
   if (std::string("Cs") == UEAlgo) {
     mEvent.getByToken(etaToken_, etaRanges);
     mEvent.getByToken(rhoToken_, rho);
     mEvent.getByToken(rhomToken_, rhom);
     const int rhoSize = (int)etaRanges->size();
     double rhoRange[rhoSize];
     for (int irho = 0; irho < rhoSize; irho++) {
       rhoRange[irho] = etaRanges->at(irho);
     }
     double yaxisLimits[501];
     for (int ibin = 0; ibin < 501; ibin++)
       yaxisLimits[ibin] = ibin * 2;
     if (mRhoDist_vsEta->getNbinsX() != rhoSize - 1) {
       mRhoDist_vsEta->getTH2F()->SetBins(
           rhoSize - 1, const_cast<double *>(rhoRange), 500, const_cast<double *>(yaxisLimits));
       mRhoMDist_vsEta->getTH2F()->SetBins(
           rhoSize - 1, const_cast<double *>(rhoRange), 500, const_cast<double *>(yaxisLimits));
     }
   }
 
   if (isCaloJet)
     mEvent.getByToken(caloJetsToken_, caloJets);
   if (isJPTJet)
     mEvent.getByToken(jptJetsToken_, jptJets);
   if (isPFJet) {
     if (std::string("Pu") == UEAlgo)
       mEvent.getByToken(basicJetsToken_, basicJets);
     if (std::string("Cs") == UEAlgo)
       mEvent.getByToken(pfJetsToken_, pfJets);
     if (std::string("Vs") == UEAlgo)
       return;  //avoid running Vs jets
   }
 
   mEvent.getByToken(pfCandToken_, pfCandidates);
   mEvent.getByToken(pfCandViewToken_, pfcandidates_);
   if (std::string("Cs") == UEAlgo)
     mEvent.getByToken(csCandToken_, csCandidates);
 
   mEvent.getByToken(caloTowersToken_, caloCandidates);
   mEvent.getByToken(caloCandViewToken_, calocandidates_);
 
   // get the centrality
   edm::Handle<reco::Centrality> cent;
   mEvent.getByToken(centralityToken, cent);  //_centralitytag comes from the cfg
 
   mHF->Fill(cent->EtHFtowerSum());
   Float_t HF_energy = cent->EtHFtowerSum();
 
   //for later when centrality gets added to RelVal
   //edm::Handle<int> cbin;
   //mEvent.getByToken(centralityBinToken, cbin);
 
   if (!cent.isValid())
     return;
 
   /*int hibin = -999;
   if(cbin.isValid()){
     hibin = *cbin;
   }*/
 
   const reco::PFCandidateCollection *pfCandidateColl = pfCandidates.product();
 
   Int_t NPFpart = 0;
   Int_t NCaloTower = 0;
   Float_t pfPt = 0;
   Float_t pfEta = 0;
   Float_t pfPhi = 0;
   Int_t pfID = 0;
   Float_t pfDeltaR = 0;
   Float_t caloPt = 0;
   Float_t caloEta = 0;
   Float_t caloPhi = 0;
   Float_t SumPt_value = 0;
 
   vector<vector<float>> numbers;
   vector<float> tempVector;
   numbers.clear();
   tempVector.clear();
 
   if (isCaloJet) {
     Float_t SumCaloPt[etaBins_];
     Float_t SumSquaredCaloPt[etaBins_];
 
     // Need to set up histograms to get the RMS values for each pT bin
     TH1F *hSumCaloPt[nedge_pseudorapidity - 1];
 
     for (int i = 0; i < etaBins_; ++i) {
       SumCaloPt[i] = 0;
       SumSquaredCaloPt[i] = 0;
       hSumCaloPt[i] = new TH1F(Form("hSumCaloPt_%d", i), "", 10000, -10000, 10000);
     }
 
     for (unsigned icand = 0; icand < caloCandidates->size(); icand++) {
       const CaloTower &tower = (*caloCandidates)[icand];
       reco::CandidateViewRef ref(calocandidates_, icand);
       //10 is tower pT min
       if (tower.p4(vtx).Et() < 0.1)
         continue;
 
       NCaloTower++;
 
       caloPt = tower.p4(vtx).Et();
       caloEta = tower.p4(vtx).Eta();
       caloPhi = tower.p4(vtx).Phi();
 
       for (size_t k = 0; k < nedge_pseudorapidity - 1; k++) {
         if (caloEta >= edge_pseudorapidity[k] && caloEta < edge_pseudorapidity[k + 1]) {
           SumCaloPt[k] = SumCaloPt[k] + caloPt;
           SumSquaredCaloPt[k] = SumSquaredCaloPt[k] + caloPt * caloPt;
           break;
         }  // eta selection statement
 
       }  // eta bin loop
 
       SumPt_value = SumPt_value + caloPt;
 
       mCaloPt->Fill(caloPt);
       mCaloEta->Fill(caloEta);
       mCaloPhi->Fill(caloPhi);
 
     }  // calo tower candidate  loop
 
     for (int k = 0; k < nedge_pseudorapidity - 1; k++) {
       hSumCaloPt[k]->Fill(SumCaloPt[k]);
 
     }  // eta bin loop
 
     Float_t Evt_SumCaloPt = 0;
     Float_t Evt_SumSquaredCaloPt = 0;
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       mSumCaloPtEtaDep[ieta]->Fill(SumCaloPt[ieta]);
     }
 
     for (size_t k = 0; k < nedge_pseudorapidity - 1; k++) {
       Evt_SumCaloPt = Evt_SumCaloPt + SumCaloPt[k];
       mSumCaloPt_eta->Fill(edge_pseudorapidity[k], SumCaloPt[k]);
 
       Evt_SumSquaredCaloPt = Evt_SumSquaredCaloPt + SumSquaredCaloPt[k];
       mSumSquaredCaloPt_eta->Fill(edge_pseudorapidity[k], hSumCaloPt[k]->GetRMS(1));
 
       delete hSumCaloPt[k];
 
     }  // eta bin loop
 
     mSumCaloPt->Fill(Evt_SumCaloPt);
     mSumCaloPt_HF->Fill(Evt_SumCaloPt, HF_energy);
 
     mSumSquaredCaloPt->Fill(Evt_SumSquaredCaloPt);
 
     mNCalopart->Fill(NCaloTower);
     mSumpt->Fill(SumPt_value);
 
   }  // is calo jet
 
   if (isPFJet) {
     Float_t SumPFPt[etaBins_];
 
     Float_t SumSquaredPFPt[etaBins_];
 
     // Need to set up histograms to get the RMS values for each pT bin
     TH1F *hSumPFPt[nedge_pseudorapidity - 1];
 
     for (int i = 0; i < etaBins_; i++) {
       SumPFPt[i] = 0;
       SumSquaredPFPt[i] = 0;
 
       hSumPFPt[i] = new TH1F(Form("hSumPFPt_%d", i), "", 10000, -10000, 10000);
     }
 
     vector<vector<float>> PF_Space(1, vector<float>(3));
 
     if (std::string("Cs") == UEAlgo) {
       const reco::PFCandidateCollection *csCandidateColl = csCandidates.product();
 
       for (unsigned iCScand = 0; iCScand < csCandidateColl->size(); iCScand++) {
         assert(csCandidateColl->size() <= pfCandidateColl->size());
         const reco::PFCandidate csCandidate = csCandidateColl->at(iCScand);
         const reco::PFCandidate pfCandidate = pfCandidateColl->at(iCScand);
         int ieta = 0;
         while (csCandidate.eta() > edge_pseudorapidity[ieta] && ieta < etaBins_ - 1)
           ieta++;
         mCSCandpT_vsPt[ieta]->Fill(csCandidate.pt());
         mCSCand_corrPFcand[ieta]->Fill(csCandidate.pt(), pfCandidate.pt());
       }
     }
 
     for (unsigned icand = 0; icand < pfCandidateColl->size(); icand++) {
       const reco::PFCandidate pfCandidate = pfCandidateColl->at(icand);
       reco::CandidateViewRef ref(pfcandidates_, icand);
       if (pfCandidate.pt() < 5)
         continue;
 
       NPFpart++;
       pfPt = pfCandidate.pt();
       pfEta = pfCandidate.eta();
       pfPhi = pfCandidate.phi();
       pfID = pfCandidate.particleId();
 
       bool isBarrel = false;
       bool isEndcap = false;
       bool isForward = false;
 
       if (fabs(pfEta) < BarrelEta)
         isBarrel = true;
       if (fabs(pfEta) >= BarrelEta && fabs(pfEta) < EndcapEta)
         isEndcap = true;
       if (fabs(pfEta) >= EndcapEta && fabs(pfEta) < ForwardEta)
         isForward = true;
 
       switch (pfID) {
         case 0:
           mPFCandpT_vs_eta_Unknown->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_Unknown->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_Unknown->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_Unknown->Fill(pfPt);
           break;
         case 1:
           mPFCandpT_vs_eta_ChargedHadron->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_ChargedHadron->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_ChargedHadron->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_ChargedHadron->Fill(pfPt);
           break;
         case 2:
           mPFCandpT_vs_eta_electron->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_electron->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_electron->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_electron->Fill(pfPt);
           break;
         case 3:
           mPFCandpT_vs_eta_muon->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_muon->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_muon->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_muon->Fill(pfPt);
           break;
         case 4:
           mPFCandpT_vs_eta_photon->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_photon->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_photon->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_photon->Fill(pfPt);
           break;
         case 5:
           mPFCandpT_vs_eta_NeutralHadron->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_NeutralHadron->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_NeutralHadron->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_NeutralHadron->Fill(pfPt);
           break;
         case 6:
           mPFCandpT_vs_eta_HadE_inHF->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_HadE_inHF->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_HadE_inHF->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_HadE_inHF->Fill(pfPt);
           break;
         case 7:
           mPFCandpT_vs_eta_EME_inHF->Fill(pfPt, pfEta);
           if (isBarrel)
             mPFCandpT_Barrel_EME_inHF->Fill(pfPt);
           if (isEndcap)
             mPFCandpT_Endcap_EME_inHF->Fill(pfPt);
           if (isForward)
             mPFCandpT_Forward_EME_inHF->Fill(pfPt);
           break;
       }
 
       //Fill 2d vector matrix
       tempVector.push_back(pfPt);
       tempVector.push_back(pfEta);
       tempVector.push_back(pfPhi);
 
       numbers.push_back(tempVector);
       tempVector.clear();
 
       for (size_t k = 0; k < nedge_pseudorapidity - 1; k++) {
         if (pfEta >= edge_pseudorapidity[k] && pfEta < edge_pseudorapidity[k + 1]) {
           SumPFPt[k] = SumPFPt[k] + pfPt;
           SumSquaredPFPt[k] = SumSquaredPFPt[k] + pfPt * pfPt;
           break;
         }  // eta selection statement
 
       }  // eta bin loop
 
       SumPt_value = SumPt_value + pfPt;
 
       mPFPt->Fill(pfPt);
       mPFEta->Fill(pfEta);
       mPFPhi->Fill(pfPhi);
 
     }  // pf candidate loop
 
     for (int k = 0; k < nedge_pseudorapidity - 1; k++) {
       hSumPFPt[k]->Fill(SumPFPt[k]);
 
     }  // eta bin loop
 
     Float_t Evt_SumPFPt = 0;
     Float_t Evt_SumSquaredPFPt = 0;
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       mSumPFPtEtaDep[ieta]->Fill(SumPFPt[ieta]);
     }
 
     for (size_t k = 0; k < nedge_pseudorapidity - 1; k++) {
       Evt_SumPFPt = Evt_SumPFPt + SumPFPt[k];
       mSumPFPt_eta->Fill(edge_pseudorapidity[k], SumPFPt[k]);
 
       Evt_SumSquaredPFPt = Evt_SumSquaredPFPt + SumSquaredPFPt[k];
       mSumSquaredPFPt_eta->Fill(edge_pseudorapidity[k], hSumPFPt[k]->GetRMS(1));
 
       delete hSumPFPt[k];
 
     }  // eta bin loop
 
     mSumPFPt->Fill(Evt_SumPFPt);
     mSumPFPt_HF->Fill(Evt_SumPFPt, HF_energy);
 
     mSumSquaredPFPt->Fill(Evt_SumSquaredPFPt);
 
     mNPFpart->Fill(NPFpart);
     mSumpt->Fill(SumPt_value);
   }
 
   if (isCaloJet) {
     for (unsigned ijet = 0; ijet < caloJets->size(); ijet++) {
       recoJets.push_back((*caloJets)[ijet]);
     }
   }
 
   if (isJPTJet) {
     for (unsigned ijet = 0; ijet < jptJets->size(); ijet++)
       recoJets.push_back((*jptJets)[ijet]);
   }
 
   if (isPFJet) {
     if (std::string("Pu") == UEAlgo) {
       for (unsigned ijet = 0; ijet < basicJets->size(); ijet++) {
         recoJets.push_back((*basicJets)[ijet]);
       }
     }
     if (std::string("Cs") == UEAlgo) {
       for (unsigned ijet = 0; ijet < pfJets->size(); ijet++) {
         recoJets.push_back((*pfJets)[ijet]);
       }
     }
   }
 
   if (isCaloJet && !caloJets.isValid()) {
     return;
   }
   if (isJPTJet && !jptJets.isValid()) {
     return;
   }
   if (isPFJet) {
     if (std::string("Pu") == UEAlgo) {
       if (!basicJets.isValid())
         return;
     }
     if (std::string("Cs") == UEAlgo) {
       if (!pfJets.isValid())
         return;
     }
     if (std::string("Vs") == UEAlgo) {
       return;
     }
   }
 
   int nJet_40 = 0;
 
   mNJets->Fill(recoJets.size());
 
   for (unsigned ijet = 0; ijet < recoJets.size(); ijet++) {
     if (recoJets[ijet].pt() > mRecoJetPtThreshold) {
       //counting forward and barrel jets
       // get an idea of no of jets with pT>40 GeV
       if (recoJets[ijet].pt() > 40)
         nJet_40++;
       if (mEta)
         mEta->Fill(recoJets[ijet].eta());
       if (mjetpileup)
         mjetpileup->Fill(recoJets[ijet].pileup());
       if (mJetArea)
         mJetArea->Fill(recoJets[ijet].jetArea());
       if (mPhi)
         mPhi->Fill(recoJets[ijet].phi());
       if (mEnergy)
         mEnergy->Fill(recoJets[ijet].energy());
       if (mP)
         mP->Fill(recoJets[ijet].p());
       if (mPt)
         mPt->Fill(recoJets[ijet].pt());
       if (mMass)
         mMass->Fill(recoJets[ijet].mass());
       if (mConstituents)
         mConstituents->Fill(recoJets[ijet].nConstituents());
 
       if (std::string("Cs") == UEAlgo) {
         int ipt = 0, ieta = 0;
         while (recoJets[ijet].pt() > ptBin[ipt + 1] && ipt < ptBins_ - 1)
           ipt++;
         while (recoJets[ijet].eta() > etaRanges->at(ieta + 1) && ieta < (int)(rho->size() - 1))
           ieta++;
         mSubtractedEFrac[ipt][ieta]->Fill((double)recoJets[ijet].pileup() / (double)recoJets[ijet].energy());
         mSubtractedE[ipt][ieta]->Fill(recoJets[ijet].pileup());
 
         for (unsigned irho = 0; irho < rho->size(); irho++) {
           mRhoDist_vsEta->Fill(recoJets[ijet].eta(), rho->at(irho));
           mRhoMDist_vsEta->Fill(recoJets[ijet].eta(), rhom->at(irho));
           mRhoDist_vsPt->Fill(recoJets[ijet].pt(), rho->at(irho));
           mRhoMDist_vsPt->Fill(recoJets[ijet].pt(), rhom->at(irho));
           mRhoDist_vsCent[ieta]->Fill(HF_energy, rho->at(irho));
           mRhoMDist_vsCent[ieta]->Fill(HF_energy, rhom->at(irho));
         }
       }
 
       for (size_t iii = 0; iii < numbers.size(); iii++) {
         pfDeltaR = sqrt((numbers[iii][2] - recoJets[ijet].phi()) * (numbers[iii][2] - recoJets[ijet].phi()) +
                         (numbers[iii][1] - recoJets[ijet].eta()) * (numbers[iii][1] - recoJets[ijet].eta()));  //MZ
 
         mPFDeltaR->Fill(pfDeltaR);                                  //MZ
         mPFDeltaR_Scaled_R->Fill(pfDeltaR, 1. / pow(pfDeltaR, 2));  //MZ
       }
     }
   }
   if (mNJets_40)
     mNJets_40->Fill(nJet_40);
 
   numbers.clear();
 }

◆ bookHistograms()

void JetAnalyzer_HeavyIons::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 183 of file JetAnalyzer_HeavyIons.cc.

References funct::abs(), BarrelEta, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), edge_pseudorapidity, EndcapEta, etaBins_, ForwardEta, HltBtagPostValidation_cff::histoName, hcalRecHitTable_cff::ieta, isCaloJet, isPFJet, edm::InputTag::label(), mCaloEta, mCaloPhi, mCaloPt, mConstituents, mCSCand_corrPFcand, mCSCandpT_vsPt, mEnergy, mEta, mHF, mInputCollection, mJetArea, mjetpileup, mMass, mNCalopart, mNJets, mNJets_40, mNPFpart, mNvtx, mOutputFile, mP, mPFCandpT_Barrel_ChargedHadron, mPFCandpT_Barrel_electron, mPFCandpT_Barrel_EME_inHF, mPFCandpT_Barrel_HadE_inHF, mPFCandpT_Barrel_muon, mPFCandpT_Barrel_NeutralHadron, mPFCandpT_Barrel_photon, mPFCandpT_Barrel_Unknown, mPFCandpT_Endcap_ChargedHadron, mPFCandpT_Endcap_electron, mPFCandpT_Endcap_EME_inHF, mPFCandpT_Endcap_HadE_inHF, mPFCandpT_Endcap_muon, mPFCandpT_Endcap_NeutralHadron, mPFCandpT_Endcap_photon, mPFCandpT_Endcap_Unknown, mPFCandpT_Forward_ChargedHadron, mPFCandpT_Forward_electron, mPFCandpT_Forward_EME_inHF, mPFCandpT_Forward_HadE_inHF, mPFCandpT_Forward_muon, mPFCandpT_Forward_NeutralHadron, mPFCandpT_Forward_photon, mPFCandpT_Forward_Unknown, mPFCandpT_vs_eta_ChargedHadron, mPFCandpT_vs_eta_electron, mPFCandpT_vs_eta_EME_inHF, mPFCandpT_vs_eta_HadE_inHF, mPFCandpT_vs_eta_muon, mPFCandpT_vs_eta_NeutralHadron, mPFCandpT_vs_eta_photon, mPFCandpT_vs_eta_Unknown, mPFDeltaR, mPFDeltaR_Scaled_R, mPFEta, mPFPhi, mPFPt, mPhi, mPt, mRhoDist_vsCent, mRhoDist_vsEta, mRhoDist_vsPt, mRhoMDist_vsCent, mRhoMDist_vsEta, mRhoMDist_vsPt, mSubtractedE, mSubtractedEFrac, mSumCaloPt, mSumCaloPt_eta, mSumCaloPt_HF, mSumCaloPtEtaDep, mSumPFPt, mSumPFPt_eta, mSumPFPt_HF, mSumPFPtEtaDep, mSumpt, mSumSquaredCaloPt, mSumSquaredCaloPt_eta, mSumSquaredPFPt, mSumSquaredPFPt_eta, ptBin, ptBins_, FastTimerService_cff::range, rhoEtaRange, patElectronDRNCorrector_cfi::rhoName, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and UEAlgo.

                                                                         {
   ibooker.setCurrentFolder("JetMET/HIJetValidation/" + mInputCollection.label());
 
   TH2F *h2D_etabins_vs_pt2 =
       new TH2F("h2D_etabins_vs_pt2", ";#eta;sum p_{T}^{2}", etaBins_, edge_pseudorapidity, 10000, 0, 10000);
   TH2F *h2D_etabins_vs_pt =
       new TH2F("h2D_etabins_vs_pt", ";#eta;sum p_{T}", etaBins_, edge_pseudorapidity, 500, 0, 500);
   TH2F *h2D_pfcand_etabins_vs_pt =
       new TH2F("h2D_etabins_vs_pt", ";#eta;sum p_{T}", etaBins_, edge_pseudorapidity, 300, 0, 300);
 
   const int nHihfBins = 100;
   const double hihfBins[nHihfBins + 1] = {
       0,           11.282305,   11.82962,    12.344717,   13.029054,   13.698554,   14.36821,    15.140326,
       15.845786,   16.684441,   17.449186,   18.364939,   19.247023,   20.448898,   21.776642,   22.870239,
       24.405788,   26.366919,   28.340206,   30.661842,   33.657627,   36.656773,   40.028049,   44.274784,
       48.583706,   52.981358,   56.860199,   61.559853,   66.663689,   72.768196,   78.265915,   84.744431,
       92.483459,   100.281021,  108.646576,  117.023911,  125.901093,  135.224899,  147.046875,  159.864258,
       171.06015,   184.76535,   197.687103,  212.873535,  229.276413,  245.175369,  262.498322,  280.54599,
       299.570801,  317.188446,  336.99881,   357.960144,  374.725922,  400.638367,  426.062103,  453.07251,
       483.99704,   517.556396,  549.421143,  578.050781,  608.358643,  640.940979,  680.361755,  719.215027,
       757.798645,  793.882385,  839.83728,   887.268127,  931.233276,  980.856689,  1023.191833, 1080.281494,
       1138.363892, 1191.303345, 1251.439453, 1305.288818, 1368.290894, 1433.700684, 1501.597412, 1557.918335,
       1625.636475, 1695.08374,  1761.771484, 1848.941162, 1938.178345, 2027.55603,  2127.364014, 2226.186523,
       2315.188965, 2399.225342, 2501.608643, 2611.077881, 2726.316162, 2848.74707,  2972.975342, 3096.565674,
       3219.530762, 3361.178223, 3568.028564, 3765.690186, 50000};
 
   TH2F *h2D_etabins_forRho =
       new TH2F("etabinsForRho", "#rho vs. #eta;#eta;#rho", etaBins_, edge_pseudorapidity, 500, 0, 300);
   TH2F *h2D_ptBins_forRho = new TH2F("ptBinsForRho", "#rho vs. p_{T};p_{T};#rho", 300, 0, 300, 500, 0, 300);
   TH2F *h2D_centBins_forRho = new TH2F("centBinsForRho", "dummy;HIHF;#rho", nHihfBins, hihfBins, 500, 0, 300);
 
   TH2F *h2D_etabins_forRhoM =
       new TH2F("etabinsForRho", "#rho_{M} vs. #eta;#eta;#rho_{M}", etaBins_, edge_pseudorapidity, 100, 0, 1.5);
   TH2F *h2D_ptBins_forRhoM = new TH2F("ptBinsForRho", "#rho_{M} vs. p_{T};p_{T};#rho_{M}", 300, 0, 300, 100, 0, 1.5);
   TH2F *h2D_centBins_forRhoM = new TH2F("centBinsForRho", "dummy;HIHF;#rho_{M}", nHihfBins, hihfBins, 100, 0, 1.5);
 
   if (isPFJet) {
     mNPFpart = ibooker.book1D("NPFpart", "No of particle flow candidates", 1000, 0, 1000);
     mPFPt = ibooker.book1D("PFPt", "PF candidate p_{T}", 10000, -500, 500);
     mPFEta = ibooker.book1D("PFEta", "PF candidate #eta", 120, -6, 6);
     mPFPhi = ibooker.book1D("PFPhi", "PF candidate #phi", 70, -3.5, 3.5);
 
     mPFDeltaR = ibooker.book1D("PFDeltaR", "PF candidate DeltaR", 100, 0, 4);  //MZ
     mPFDeltaR_Scaled_R =
         ibooker.book1D("PFDeltaR_Scaled_R", "PF candidate DeltaR Divided by DeltaR square", 100, 0, 4);  //MZ
 
     mSumPFPt = ibooker.book1D("SumPFPt", "Sum of initial PF p_{T}", 1000, -10000, 10000);
     mSumPFPt_eta = ibooker.book2D("SumPFPt_etaBins", h2D_etabins_vs_pt);
 
     mSumSquaredPFPt = ibooker.book1D("SumSquaredPFPt", "Sum of initial PF p_{T} squared", 10000, 0, 10000);
     mSumSquaredPFPt_eta = ibooker.book2D("SumSquaredPFPt_etaBins", h2D_etabins_vs_pt2);
 
     mSumPFPt_HF = ibooker.book2D(
         "SumPFPt_HF", "HF energy (y axis) vs Sum initial PF p_{T} (x axis)", 1000, -1000, 1000, 1000, 0, 10000);
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       int range = 1000;
       if (ieta < 2 || etaBins_ - ieta <= 2)
         range = 500;
       const char *lc = edge_pseudorapidity[ieta] < 0 ? "n" : "p";
       const char *rc = edge_pseudorapidity[ieta + 1] < 0 ? "n" : "p";
       std::string histoName =
           Form("mSumCaloPt_%s%.3g_%s%.3g", lc, abs(edge_pseudorapidity[ieta]), rc, abs(edge_pseudorapidity[ieta + 1]));
       for (int id = 0; id < 2; id++) {
         if (histoName.find('.') != std::string::npos) {
           histoName.replace(histoName.find('.'), 1, "p");
         }
       }
       mSumPFPtEtaDep[ieta] = ibooker.book1D(
           histoName.c_str(),
           Form("Sum PFPt in the eta range %.3g to %.3g", edge_pseudorapidity[ieta], edge_pseudorapidity[ieta + 1]),
           500,
           0,
           range);
     }
 
     if (std::string("Cs") == UEAlgo) {
       mRhoDist_vsEta = ibooker.book2D("rhoDist_vsEta", h2D_etabins_forRho);
       mRhoMDist_vsEta = ibooker.book2D("rhoMDist_vsEta", h2D_etabins_forRhoM);
       mRhoDist_vsPt = ibooker.book2D("rhoDist_vsPt", h2D_ptBins_forRho);
       mRhoMDist_vsPt = ibooker.book2D("rhoMDist_vsPt", h2D_ptBins_forRhoM);
 
       //this is kind of a janky way to fill the eta since i can't get it from the edm::Event here... - kjung
       rhoEtaRange = ibooker.book1D("rhoEtaRange", "", 500, -5.5, 5.5);
       for (int ieta = 0; ieta < etaBins_; ieta++) {
         mCSCandpT_vsPt[ieta] =
             ibooker.book1D(Form("csCandPt_etaBin%d", ieta), "CS candidate pt, eta-by-eta", 150, 0, 300);
 
         const char *lc = edge_pseudorapidity[ieta] < 0 ? "n" : "p";
         const char *rc = edge_pseudorapidity[ieta + 1] < 0 ? "n" : "p";
         std::string histoName = Form(
             "Dist_vsCent_%s%.3g_%s%.3g", lc, abs(edge_pseudorapidity[ieta]), rc, abs(edge_pseudorapidity[ieta + 1]));
         for (int id = 0; id < 2; id++) {
           if (histoName.find('.') != std::string::npos) {
             histoName.replace(histoName.find('.'), 1, "p");
           }
         }
         std::string rhoName = "rho";
         rhoName.append(histoName);
         h2D_centBins_forRho->SetTitle(Form(
             "#rho vs. HIHF in the range %.3g < #eta < %.3g", edge_pseudorapidity[ieta], edge_pseudorapidity[ieta + 1]));
         mRhoDist_vsCent[ieta] = ibooker.book2D(rhoName.c_str(), h2D_centBins_forRho);
         std::string rhoMName = "rhoM";
         rhoMName.append(histoName);
         h2D_centBins_forRhoM->SetTitle(Form("#rho_{M} vs. HIHF in the range %.3g < #eta < %.3g",
                                             edge_pseudorapidity[ieta],
                                             edge_pseudorapidity[ieta + 1]));
         mRhoMDist_vsCent[ieta] = ibooker.book2D(rhoMName.c_str(), h2D_centBins_forRhoM);
         for (int ipt = 0; ipt < ptBins_; ipt++) {
           mSubtractedEFrac[ipt][ieta] =
               ibooker.book1D(Form("subtractedEFrac_JetPt%d_to_%d_etaBin%d", ptBin[ipt], ptBin[ipt + 1], ieta),
                              "subtracted fraction of CS jet",
                              50,
                              0,
                              1);
           mSubtractedE[ipt][ieta] =
               ibooker.book1D(Form("subtractedE_JetPt%d_to_%d_etaBin%d", ptBin[ipt], ptBin[ipt + 1], ieta),
                              "subtracted total of CS jet",
                              300,
                              0,
                              300);
         }
         mCSCand_corrPFcand[ieta] = ibooker.book2D(
             Form("csCandCorrPF%d", ieta), "CS to PF candidate correlation, eta-by-eta", 300, 0, 300, 300, 0, 300);
       }
     }
 
     mPFCandpT_vs_eta_Unknown = ibooker.book2D("PF_cand_X_unknown", h2D_pfcand_etabins_vs_pt);         // pf id 0
     mPFCandpT_vs_eta_ChargedHadron = ibooker.book2D("PF_cand_chargedHad", h2D_pfcand_etabins_vs_pt);  // pf id - 1
     mPFCandpT_vs_eta_electron = ibooker.book2D("PF_cand_electron", h2D_pfcand_etabins_vs_pt);         // pf id - 2
     mPFCandpT_vs_eta_muon = ibooker.book2D("PF_cand_muon", h2D_pfcand_etabins_vs_pt);                 // pf id - 3
     mPFCandpT_vs_eta_photon = ibooker.book2D("PF_cand_photon", h2D_pfcand_etabins_vs_pt);             // pf id - 4
     mPFCandpT_vs_eta_NeutralHadron = ibooker.book2D("PF_cand_neutralHad", h2D_pfcand_etabins_vs_pt);  // pf id - 5
     mPFCandpT_vs_eta_HadE_inHF = ibooker.book2D("PF_cand_HadEner_inHF", h2D_pfcand_etabins_vs_pt);    // pf id - 6
     mPFCandpT_vs_eta_EME_inHF = ibooker.book2D("PF_cand_EMEner_inHF", h2D_pfcand_etabins_vs_pt);      // pf id - 7
 
     mPFCandpT_Barrel_Unknown = ibooker.book1D("mPFCandpT_Barrel_Unknown",
                                               Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                               300,
                                               0,
                                               300);  // pf id  - 0
     mPFCandpT_Barrel_ChargedHadron = ibooker.book1D("mPFCandpT_Barrel_ChargedHadron",
                                                     Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                                     300,
                                                     0,
                                                     300);  // pf id - 1
     mPFCandpT_Barrel_electron = ibooker.book1D("mPFCandpT_Barrel_electron",
                                                Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                                300,
                                                0,
                                                300);  // pf id - 2
     mPFCandpT_Barrel_muon = ibooker.book1D("mPFCandpT_Barrel_muon",
                                            Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                            300,
                                            0,
                                            300);  // pf id - 3
     mPFCandpT_Barrel_photon = ibooker.book1D("mPFCandpT_Barrel_photon",
                                              Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                              300,
                                              0,
                                              300);  // pf id - 4
     mPFCandpT_Barrel_NeutralHadron = ibooker.book1D("mPFCandpT_Barrel_NeutralHadron",
                                                     Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                                     300,
                                                     0,
                                                     300);  // pf id - 5
     mPFCandpT_Barrel_HadE_inHF = ibooker.book1D("mPFCandpT_Barrel_HadE_inHF",
                                                 Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                                 300,
                                                 0,
                                                 300);  // pf id - 6
     mPFCandpT_Barrel_EME_inHF = ibooker.book1D("mPFCandpT_Barrel_EME_inHF",
                                                Form(";PF candidate p_{T}, |#eta|<%2.2f; counts", BarrelEta),
                                                300,
                                                0,
                                                300);  // pf id - 7
 
     mPFCandpT_Endcap_Unknown =
         ibooker.book1D("mPFCandpT_Endcap_Unknown",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 0
     mPFCandpT_Endcap_ChargedHadron =
         ibooker.book1D("mPFCandpT_Endcap_ChargedHadron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 1
     mPFCandpT_Endcap_electron =
         ibooker.book1D("mPFCandpT_Endcap_electron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 2
     mPFCandpT_Endcap_muon =
         ibooker.book1D("mPFCandpT_Endcap_muon",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 3
     mPFCandpT_Endcap_photon =
         ibooker.book1D("mPFCandpT_Endcap_photon",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 4
     mPFCandpT_Endcap_NeutralHadron =
         ibooker.book1D("mPFCandpT_Endcap_NeutralHadron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 5
     mPFCandpT_Endcap_HadE_inHF =
         ibooker.book1D("mPFCandpT_Endcap_HadE_inHF",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 6
     mPFCandpT_Endcap_EME_inHF =
         ibooker.book1D("mPFCandpT_Endcap_EME_inHF",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", BarrelEta, EndcapEta),
                        300,
                        0,
                        300);  // pf id - 7
 
     mPFCandpT_Forward_Unknown =
         ibooker.book1D("mPFCandpT_Forward_Unknown",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 0
     mPFCandpT_Forward_ChargedHadron =
         ibooker.book1D("mPFCandpT_Forward_ChargedHadron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 1
     mPFCandpT_Forward_electron =
         ibooker.book1D("mPFCandpT_Forward_electron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 2
     mPFCandpT_Forward_muon =
         ibooker.book1D("mPFCandpT_Forward_muon",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 3
     mPFCandpT_Forward_photon =
         ibooker.book1D("mPFCandpT_Forward_photon",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 4
     mPFCandpT_Forward_NeutralHadron =
         ibooker.book1D("mPFCandpT_Forward_NeutralHadron",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 5
     mPFCandpT_Forward_HadE_inHF =
         ibooker.book1D("mPFCandpT_Forward_HadE_inHF",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 6
     mPFCandpT_Forward_EME_inHF =
         ibooker.book1D("mPFCandpT_Forward_EME_inHF",
                        Form(";PF candidate p_{T}, %2.2f<|#eta|<%2.2f; counts", EndcapEta, ForwardEta),
                        300,
                        0,
                        300);  // pf id - 7
   }
 
   if (isCaloJet) {
     mNCalopart = ibooker.book1D("NCalopart", "No of particle flow candidates", 1000, 0, 10000);
     mCaloPt = ibooker.book1D("CaloPt", "Calo candidate p_{T}", 1000, -5000, 5000);
     mCaloEta = ibooker.book1D("CaloEta", "Calo candidate #eta", 120, -6, 6);
     mCaloPhi = ibooker.book1D("CaloPhi", "Calo candidate #phi", 70, -3.5, 3.5);
 
     mSumCaloPt = ibooker.book1D("SumCaloPt", "Sum Calo p_{T}", 1000, -10000, 10000);
     mSumCaloPt_eta = ibooker.book2D("SumCaloPt_etaBins", h2D_etabins_vs_pt);
 
     mSumSquaredCaloPt = ibooker.book1D("SumSquaredCaloPt", "Sum of initial Calo tower p_{T} squared", 10000, 0, 10000);
     mSumSquaredCaloPt_eta = ibooker.book2D("SumSquaredCaloPt_etaBins", h2D_etabins_vs_pt2);
 
     mSumCaloPt_HF =
         ibooker.book2D("SumCaloPt_HF", "HF Energy (y axis) vs Sum Calo tower p_{T}", 1000, -1000, 1000, 1000, 0, 10000);
 
     for (int ieta = 0; ieta < etaBins_; ieta++) {
       int range = 1000;
       if (ieta < 2 || etaBins_ - ieta <= 2)
         range = 5000;
       const char *lc = edge_pseudorapidity[ieta] < 0 ? "n" : "p";
       const char *rc = edge_pseudorapidity[ieta + 1] < 0 ? "n" : "p";
       std::string histoName =
           Form("mSumCaloPt_%s%.3g_%s%.3g", lc, abs(edge_pseudorapidity[ieta]), rc, abs(edge_pseudorapidity[ieta + 1]));
       for (int id = 0; id < 2; id++) {
         if (histoName.find('.') != std::string::npos) {
           histoName.replace(histoName.find('.'), 1, "p");
         }
       }
       mSumCaloPtEtaDep[ieta] = ibooker.book1D(histoName.c_str(),
                                               Form("Sum Calo tower Pt in the eta range %.3g to %.3g",
                                                    edge_pseudorapidity[ieta],
                                                    edge_pseudorapidity[ieta + 1]),
                                               1000,
                                               -1 * range,
                                               range);
     }
   }
 
   // particle flow variables histograms
   mSumpt = ibooker.book1D("SumpT", "Sum p_{T} of all the PF candidates per event", 1000, 0, 10000);
 
   // Event variables
   mNvtx = ibooker.book1D("Nvtx", "number of vertices", 60, 0, 60);
   mHF = ibooker.book1D("HF", "HF energy distribution", 1000, 0, 10000);
 
   // Jet parameters
   mEta = ibooker.book1D("Eta", "Eta", 120, -6, 6);
   mPhi = ibooker.book1D("Phi", "Phi", 70, -3.5, 3.5);
   mPt = ibooker.book1D("Pt", "Pt", 1000, 0, 500);
   mP = ibooker.book1D("P", "P", 100, 0, 1000);
   mEnergy = ibooker.book1D("Energy", "Energy", 100, 0, 1000);
   mMass = ibooker.book1D("Mass", "Mass", 100, 0, 200);
   mConstituents = ibooker.book1D("Constituents", "Constituents", 100, 0, 100);
   mJetArea = ibooker.book1D("JetArea", "JetArea", 100, 0, 4);
   mjetpileup = ibooker.book1D("jetPileUp", "jetPileUp", 100, 0, 150);
   mNJets_40 = ibooker.book1D("NJets_pt_greater_40", "NJets pT > 40 GeV", 50, 0, 50);
   mNJets = ibooker.book1D("NJets", "NJets", 100, 0, 100);
 
   if (mOutputFile.empty())
     LogInfo("OutputInfo") << " Histograms will NOT be saved";
   else
     LogInfo("OutputInfo") << " Histograms will be saved to file:" << mOutputFile;
 
   delete h2D_etabins_vs_pt2;
   delete h2D_etabins_vs_pt;
   delete h2D_pfcand_etabins_vs_pt;
   delete h2D_etabins_forRho;
   delete h2D_ptBins_forRho;
   delete h2D_centBins_forRho;
   delete h2D_centBins_forRhoM;
 }