#include <MBUEandQCDValidation.h>

Inheritance diagram for MBUEandQCDValidation:

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

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

void	dqmBeginRun (const edm::Run &r, const edm::EventSetup &c) override

	MBUEandQCDValidation (const edm::ParameterSet &)

	~MBUEandQCDValidation () 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

	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 Member Functions
unsigned int	getHFbin (double eta)

bool	isCharged (unsigned int i)

bool	isNeutral (unsigned int i)

bool	isNeutrino (unsigned int i)

Private Attributes
MonitorElement *	_JM25ht

MonitorElement *	_JM25njets

MonitorElement *	_JM25pt1

MonitorElement *	_JM25pt2

MonitorElement *	_JM25pt3

MonitorElement *	_JM25pt4

MonitorElement *	_JM80ht

MonitorElement *	_JM80njets

MonitorElement *	_JM80pt1

MonitorElement *	_JM80pt2

MonitorElement *	_JM80pt3

MonitorElement *	_JM80pt4

MonitorElement *	_sumEt

MonitorElement *	_sumEt1

MonitorElement *	_sumEt2

MonitorElement *	_sumEt3

MonitorElement *	_sumEt4

MonitorElement *	_sumEt5

MonitorElement *	dEdetaHFdj

MonitorElement *	dEdetaHFmb

MonitorElement *	djr10

MonitorElement *	djr21

MonitorElement *	djr32

MonitorElement *	djr43

MonitorElement *	dNchdeta1

MonitorElement *	dNchdeta2

MonitorElement *	dNchdphi

MonitorElement *	dNchdpt1

MonitorElement *	dNchdpt2

MonitorElement *	dNchdSpt

MonitorElement *	dNchjdeta

MonitorElement *	dNchjdpt

MonitorElement *	dNjdeta

MonitorElement *	dNjdpt

MonitorElement *	dSptdphi

MonitorElement *	elePt

MonitorElement *	EmpzHFm

MonitorElement *	eneHFmSel

std::vector< double >	eneInCell

edm::ESHandle< HepPDT::ParticleDataTable >	fPDGTable
	PDT table. More...

edm::ESGetToken< HepPDT::ParticleDataTable, edm::DefaultRecord >	fPDGTableToken

edm::InputTag	genchjetCollection_

edm::EDGetTokenT< reco::GenJetCollection >	genchjetCollectionToken_

edm::InputTag	genjetCollection_

edm::EDGetTokenT< reco::GenJetCollection >	genjetCollectionToken_

std::vector< double >	hepmcCharge

edm::InputTag	hepmcCollection_

edm::EDGetTokenT< edm::HepMCProduct >	hepmcCollectionToken_

std::vector< const HepMC::GenParticle * >	hepmcGPCollection
	status 1 GenParticle collection More...

MonitorElement *	leadChjeta

MonitorElement *	leadChjpt

MonitorElement *	leadTracketa

MonitorElement *	leadTrackpt

MonitorElement *	missEtosumJEt

MonitorElement *	muoPt

MonitorElement *	nbquark

MonitorElement *	ncandbquark

MonitorElement *	nCha

MonitorElement *	nChaDenLpt

MonitorElement *	nChj

MonitorElement *	ncnobquark

MonitorElement *	nDijet

MonitorElement *	nEvt

MonitorElement *	nEvt1
	QCD-09-010 analysis. More...

MonitorElement *	nEvt2

MonitorElement *	nGamma

MonitorElement *	nHFflow

MonitorElement *	nHFSD

MonitorElement *	nj

MonitorElement *	nK0s

MonitorElement *	nKpm

MonitorElement *	nL0

MonitorElement *	nNNbar

MonitorElement *	nNoFwdTrig

MonitorElement *	nOmega

MonitorElement *	nPPbar

MonitorElement *	nSaFwdTrig

MonitorElement *	ntHFm

MonitorElement *	nXim

MonitorElement *	pGamma

MonitorElement *	pK0s

MonitorElement *	pKpm

MonitorElement *	pL0

MonitorElement *	pNNbar

MonitorElement *	pOmega

MonitorElement *	pPPbar

MonitorElement *	pt1pt2balance

MonitorElement *	pt1pt2Dphi

MonitorElement *	pt1pt2InvM

MonitorElement *	pt1pt2optot

MonitorElement *	pt1pt2optotch

MonitorElement *	pt3Frac

MonitorElement *	pXim

MonitorElement *	sptDenLpt

MonitorElement *	sumChPt

MonitorElement *	sumJEt

MonitorElement *	sumPt

CaloCellManager *	theCalo
	manager of calorimetric cell structure More...

unsigned int	verbosity_

WeightManager	wmanager_

Static Private Attributes
static const unsigned int	initSize = 1000

static const unsigned int	nphiBin = 36

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 37 of file MBUEandQCDValidation.h.

Constructor & Destructor Documentation

◆ MBUEandQCDValidation()

MBUEandQCDValidation::MBUEandQCDValidation ( const edm::ParameterSet & iPSet )

explicit

Definition at line 19 of file MBUEandQCDValidation.cc.

References eneInCell, fPDGTableToken, genchjetCollection_, genchjetCollectionToken_, genjetCollection_, genjetCollectionToken_, hepmcCharge, hepmcCollection_, hepmcCollectionToken_, hepmcGPCollection, initSize, CaloCellManager::nCaloCell, theCalo, and verbosity_.

     : wmanager_(iPSet, consumesCollector()),
       hepmcCollection_(iPSet.getParameter<edm::InputTag>("hepmcCollection")),
       genchjetCollection_(iPSet.getParameter<edm::InputTag>("genChjetsCollection")),
       genjetCollection_(iPSet.getParameter<edm::InputTag>("genjetsCollection")),
       verbosity_(iPSet.getUntrackedParameter<unsigned int>("verbosity", 0)) {
   hepmcGPCollection.reserve(initSize);
   hepmcCharge.reserve(initSize);
 
   theCalo = new CaloCellManager(verbosity_);
 
   eneInCell.resize(CaloCellManager::nCaloCell);
 
   hepmcCollectionToken_ = consumes<HepMCProduct>(hepmcCollection_);
   genjetCollectionToken_ = consumes<reco::GenJetCollection>(genjetCollection_);
   genchjetCollectionToken_ = consumes<reco::GenJetCollection>(genchjetCollection_);
   fPDGTableToken = esConsumes<edm::Transition::BeginRun>();
 }

◆ ~MBUEandQCDValidation()

MBUEandQCDValidation::~MBUEandQCDValidation ( )

override

Definition at line 38 of file MBUEandQCDValidation.cc.

References theCalo.

38 { delete theCalo; }

MBUEandQCDValidation::theCalo

CaloCellManager * theCalo

manager of calorimetric cell structure

Definition: MBUEandQCDValidation.h:63

Member Function Documentation

◆ analyze()

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

overridevirtual

Gathering the HepMCProduct information

Reimplemented from DQMEDAnalyzer.

Definition at line 494 of file MBUEandQCDValidation.cc.

References _JM25ht, _JM25njets, _JM25pt1, _JM25pt2, _JM25pt3, _JM25pt4, _JM80ht, _JM80njets, _JM80pt1, _JM80pt2, _JM80pt3, _JM80pt4, _sumEt, _sumEt1, _sumEt2, _sumEt3, _sumEt4, _sumEt5, funct::abs(), HepMCValidationHelper::allStatus1(), ALCARECOTkAlJpsiMuMu_cff::charge, funct::cos(), gather_cfg::cout, dEdetaHFdj, dEdetaHFmb, SiPixelRawToDigiRegional_cfi::deltaPhi, djr10, djr21, djr32, djr43, dNchdeta1, dNchdeta2, dNchdphi, dNchdpt1, dNchdpt2, dNchdSpt, dNchjdeta, dNchjdpt, dNjdeta, dNjdpt, dSptdphi, elePt, EmpzHFm, eneHFmSel, eneInCell, PVValHelper::eta, dqm::impl::MonitorElement::Fill(), alignBH_cfg::fixed, CaloCellId::Forward, fPDGTable, CustomPhysics_cfi::gamma, genchjetCollectionToken_, genjetCollectionToken_, l1tCaloJetHTTProducer_cfi::genJets, CaloCellManager::getCellFromIndex(), CaloCellManager::getCellIndexFromAngle(), CaloCellId::getEtaMin(), CaloCellManager::getEtaRanges(), edm::HepMCProduct::GetEvent(), getHFbin(), CaloCellId::getSubSys(), dqm::impl::MonitorElement::getTH1(), CaloCellId::getThetaCell(), hepmcCharge, hepmcCollectionToken_, hepmcGPCollection, mps_fire::i, iEvent, createfilelist::int, isCharged(), isNeutral(), isNeutrino(), leadChjeta, leadChjpt, leadTracketa, leadTrackpt, missEtosumJEt, muoPt, CaloCellManager::nBarrelCell, CaloCellManager::nBarrelEta, nbquark, CaloCellManager::nCaloCell, ncandbquark, nCha, nChaDenLpt, nChj, ncnobquark, nDijet, CaloCellManager::nEndcapCell, CaloCellManager::nEndcapEta, nEvt, nEvt1, nEvt2, CaloCellManager::nForwardEta, nGamma, nHFflow, nHFSD, nj, nJets, nK0s, nKpm, nL0, nNNbar, nNoFwdTrig, nOmega, nphiBin, nPPbar, nSaFwdTrig, ntHFm, nXim, LHEGenericFilter_cfi::ParticleID, EgammaValidation_cff::pdgId, perp(), pGamma, phi, AlignmentTrackSelector_cfi::phiMax, pK0s, pKpm, pL0, pNNbar, pOmega, pPPbar, DiDispStaMuonMonitor_cfi::pt, HLT_2023v12_cff::pt1, pt1pt2balance, pt1pt2Dphi, pt1pt2InvM, pt1pt2optot, pt1pt2optotch, HLT_2023v12_cff::pt2, pt3Frac, AlignmentTrackSelector_cfi::ptMax, multPhiCorr_741_25nsDY_cfi::px, pXim, multPhiCorr_741_25nsDY_cfi::py, HepMCValidationHelper::removeIsolatedLeptons(), sptDenLpt, mathSSE::sqrt(), sumChPt, objects.METAnalyzer::sumEt, sumJEt, sumPt, theCalo, DiMuonV_cfg::threshold, verbosity_, WeightManager::weight(), mps_merge::weight, and wmanager_.

                                                                                       {
   edm::Handle<HepMCProduct> evt;
   iEvent.getByToken(hepmcCollectionToken_, evt);
 
   //Get HepMC EVENT
   HepMC::GenEvent* myGenEvent = new HepMC::GenEvent(*(evt->GetEvent()));
 
   double weight = wmanager_.weight(iEvent);
 
   if (verbosity_ > 0) {
     myGenEvent->print();
   }
 
   double binW = 1.;
 
   hepmcGPCollection.clear();
   hepmcCharge.clear();
   for (unsigned int i = 0; i < eneInCell.size(); i++) {
     eneInCell[i] = 0.;
   }
 
   nEvt->Fill(0.5, weight);
 
   //Looping through HepMC::GenParticle collection to search for status 1 particles
   double charge = 0.;
   unsigned int nb = 0;
   unsigned int nc = 0;
   for (HepMC::GenEvent::particle_const_iterator iter = myGenEvent->particles_begin();
        iter != myGenEvent->particles_end();
        ++iter) {
     if (std::fabs((*iter)->pdg_id()) == 4) {
       nc++;
     }
     if (std::fabs((*iter)->pdg_id()) == 5) {
       nb++;
     }
     if ((*iter)->status() == 1) {
       hepmcGPCollection.push_back(*iter);
       const HepPDT::ParticleData* PData = fPDGTable->particle(HepPDT::ParticleID((*iter)->pdg_id()));
       if (PData == nullptr) {
         charge = -999.;
       } else
         charge = PData->charge();
 
       hepmcCharge.push_back(charge);
 
       if (verbosity_ > 0) {
         std::cout << "HepMC " << std::setw(14) << std::fixed << (*iter)->barcode() << std::setw(14) << std::fixed
                   << (*iter)->pdg_id() << std::setw(14) << std::fixed << (*iter)->momentum().perp() << std::setw(14)
                   << std::fixed << (*iter)->momentum().eta() << std::setw(14) << std::fixed << (*iter)->momentum().phi()
                   << std::endl;
       }
     }
   }
 
   int nBSCp = 0;
   int nBSCm = 0;
   double eneHFp = 0.;
   double eneHFm = 0.;
   int nChapt05 = 0;
   int nChaVtx = 0;
   for (unsigned int i = 0; i < hepmcGPCollection.size(); i++) {
     if (!isNeutrino(i)) {
       // BSC trigger
 
       if (hepmcGPCollection[i]->momentum().eta() > 3.23 && hepmcGPCollection[i]->momentum().eta() < 4.65) {
         nBSCp++;
       }
       if (hepmcGPCollection[i]->momentum().eta() < -3.23 && hepmcGPCollection[i]->momentum().eta() > -4.65) {
         nBSCm++;
       }
 
       // number of charged particles in different selections
 
       if (std::fabs(hepmcGPCollection[i]->momentum().eta()) < 2.5 && hepmcGPCollection[i]->momentum().perp() > 0.5 &&
           isCharged(i)) {
         nChapt05++;
       }
       if (std::fabs(hepmcGPCollection[i]->momentum().eta()) < 2.5 && hepmcGPCollection[i]->momentum().perp() > 0.1 &&
           isCharged(i)) {
         nChaVtx++;
       }
       unsigned int theIndex = theCalo->getCellIndexFromAngle(hepmcGPCollection[i]->momentum().eta(),
                                                              hepmcGPCollection[i]->momentum().phi());
       if (theIndex < CaloCellManager::nCaloCell)
         eneInCell[theIndex] += hepmcGPCollection[i]->momentum().rho();
     }
   }
 
   // Forward calorimeters energy
 
   for (unsigned int icell = CaloCellManager::nBarrelCell + CaloCellManager::nEndcapCell;
        icell < CaloCellManager::nCaloCell;
        icell++) {
     if (theCalo->getCellFromIndex(icell)->getEtaMin() < 0.) {
       eneHFm += eneInCell[icell];
     } else {
       eneHFp += eneInCell[icell];
     }
   }
 
   // QCD-09-010 selection
   bool sel1 = false;
   if ((nBSCp > 0 || nBSCm > 0) && eneHFp >= 3. && eneHFm >= 3.) {
     sel1 = true;
   }
 
   // QCD-10-001 selection
   bool sel2 = false;
   if ((nBSCp > 0 || nBSCm > 0) && nChaVtx >= 3 && nChapt05 > 1) {
     sel2 = true;
   }
 
   // no forward trigger selection
   bool sel3 = false;
   if (nBSCp == 0 && nBSCm == 0) {
     sel3 = true;
   }
 
   // single arm forward trigger selection
   bool sel4 = false;
   if ((nBSCp > 0 && nBSCm == 0) || (nBSCm > 0 && nBSCp == 0)) {
     sel4 = true;
   }
 
   // BSC selection
   bool sel5 = false;
   if (nBSCp > 0 && nBSCm > 0) {
     sel5 = true;
   }
 
   // basic JME-10-001, FWD-10-002 and Jet-Multiplicity selection
   bool sel6 = false;
   if (sel5 && nChaVtx > 3) {
     sel6 = true;
   }
 
   // FWD-10-001 selection
   bool sel7 = false;
   if (nChaVtx >= 3 && nBSCm > 0 && eneHFp < 8.) {
     sel7 = true;
   }
 
   // Fill selection histograms
   if (sel1)
     nEvt1->Fill(0.5, weight);
   if (sel2)
     nEvt2->Fill(0.5, weight);
   if (sel3)
     nNoFwdTrig->Fill(0.5, weight);
   if (sel4)
     nSaFwdTrig->Fill(0.5, weight);
   if (sel6)
     nHFflow->Fill(0.5, weight);
   if (sel7)
     nHFSD->Fill(0.5, weight);
 
   if (nb > 0)
     nbquark->Fill(0.5, weight);
   if (nb > 0 && nc > 0)
     ncandbquark->Fill(0.5, weight);
   if (nb == 0 && nc > 0)
     ncnobquark->Fill(0.5, weight);
 
   // track analyses
   double ptMax = 0.;
   unsigned int iMax = 0;
   double ptot = 0.;
   unsigned int ppbar = 0;
   unsigned int nnbar = 0;
   unsigned int kpm = 0;
   unsigned int k0s = 0;
   unsigned int l0 = 0;
   unsigned int gamma = 0;
   unsigned int xim = 0;
   unsigned int omega = 0;
   unsigned int ele = 0;
   unsigned int muo = 0;
   unsigned int eleMax = 0;
   unsigned int muoMax = 0;
 
   std::vector<double> hfMB(CaloCellManager::nForwardEta, 0);
   std::vector<double> hfDJ(CaloCellManager::nForwardEta, 0);
 
   for (unsigned int i = 0; i < hepmcGPCollection.size(); i++) {
     double eta = hepmcGPCollection[i]->momentum().eta();
     double pt = hepmcGPCollection[i]->momentum().perp();
     int pdgId = hepmcGPCollection[i]->pdg_id();
     if (isCharged(i) && std::fabs(eta) < 2.5) {
       if (sel1) {
         // QCD-09-010
         binW = dNchdpt1->getTH1()->GetBinWidth(1);
         dNchdpt1->Fill(pt, 1. / binW);  // weight to account for the pt bin width
         binW = dNchdeta1->getTH1()->GetBinWidth(1);
         dNchdeta1->Fill(eta, 1. / binW);  // weight to account for the eta bin width
       }
       // search for the leading track QCD-10-001
       if (sel2) {
         if (pt > ptMax) {
           ptMax = pt;
           iMax = i;
         }
         ptot += pt;
 
         // identified charged particle
         if (std::abs(pdgId) == 2212) {
           ppbar++;
           pPPbar->Fill(std::log10(pt), weight);
         } else if (std::abs(pdgId) == 321) {
           kpm++;
           pKpm->Fill(std::log10(pt), weight);
         } else if (std::abs(pdgId) == 3312) {
           xim++;
           pXim->Fill(std::log10(pt), weight);
         } else if (std::abs(pdgId) == 3334) {
           omega++;
           pOmega->Fill(std::log10(pt), weight);
         } else if (std::abs(pdgId) == 11) {
           ele++;
           eleMax = i;
         } else if (std::abs(pdgId) == 13) {
           muo++;
           muoMax = i;
         }
       }
     } else if (sel2 && isNeutral(i) && std::fabs(eta) < 2.5) {
       if (std::abs(pdgId) == 310) {
         k0s++;
         pK0s->Fill(std::log10(pt), weight);
       } else if (std::abs(pdgId) == 3122) {
         l0++;
         pL0->Fill(std::log10(pt), weight);
       }
     } else if (sel2 && isNeutral(i) && std::fabs(eta) < 5.19) {
       if (std::abs(pdgId) == 2112) {
         nnbar++;
         pNNbar->Fill(std::log10(pt), weight);
       } else if (std::abs(pdgId) == 22) {
         gamma++;
         pGamma->Fill(std::log10(pt), weight);
       }
     }
     unsigned int iBin = getHFbin(eta);
     if (sel6 && !isNeutrino(i) && iBin < CaloCellManager::nForwardEta) {
       hfMB[iBin] += hepmcGPCollection[i]->momentum().rho();
     }
   }
   nPPbar->Fill(ppbar, weight);
   nNNbar->Fill(nnbar, weight);
   nKpm->Fill(kpm, weight);
   nK0s->Fill(k0s, weight);
   nL0->Fill(l0, weight);
   nXim->Fill(xim, weight);
   nOmega->Fill(omega, weight);
   nGamma->Fill(gamma, weight);
 
   if (ele > 0)
     elePt->Fill(std::log10(hepmcGPCollection[eleMax]->momentum().perp()), weight);
   if (muo > 0)
     muoPt->Fill(std::log10(hepmcGPCollection[muoMax]->momentum().perp()), weight);
 
   leadTrackpt->Fill(hepmcGPCollection[iMax]->momentum().perp(), weight);
   leadTracketa->Fill(hepmcGPCollection[iMax]->momentum().eta(), weight);
 
   std::vector<double> theEtaRanges(theCalo->getEtaRanges());
 
   for (unsigned int i = 0; i < CaloCellManager::nForwardEta; i++) {
     binW = theEtaRanges[CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta + i + 1] -
            theEtaRanges[CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta + i];
     dEdetaHFmb->Fill(i + 0.5, hfMB[i] / binW);
   }
 
   // FWD-10-001
 
   if (sel7) {
     double empz = 0.;
     unsigned int nCellOvTh = 0;
     double threshold = 0.;
 
     for (unsigned int icell = 0; icell < eneInCell.size(); icell++) {
       if (theCalo->getCellFromIndex(icell)->getSubSys() != CaloCellId::Forward) {
         threshold = 3.;
       } else {
         threshold = 4.;
       }
 
       if (eneInCell[icell] > threshold) {
         if (theCalo->getCellFromIndex(icell)->getSubSys() == CaloCellId::Forward) {
           nCellOvTh++;
         }
         empz += eneInCell[icell] * (1. - std::cos(theCalo->getCellFromIndex(icell)->getThetaCell()));
       }
     }
 
     EmpzHFm->Fill(empz, weight);
     ntHFm->Fill(nCellOvTh, weight);
     eneHFmSel->Fill(eneHFm, weight);
   }
 
   // QCD-10-001
   double phiMax = hepmcGPCollection[iMax]->momentum().phi();
   std::vector<unsigned int> nchvsphi(nphiBin, 0);
   std::vector<double> sptvsphi(nphiBin, 0.);
   unsigned int nChaTra = 0;
   double sptTra = 0.;
 
   double binPhiW = 360. / nphiBin;
   if (sel2) {
     for (unsigned int i = 0; i < hepmcGPCollection.size(); i++) {
       if (isCharged(i) && std::fabs(hepmcGPCollection[i]->momentum().eta()) < 2.) {
         double thePhi = (hepmcGPCollection[i]->momentum().phi() - phiMax) / CLHEP::degree;
         if (thePhi < -180.) {
           thePhi += 360.;
         } else if (thePhi > 180.) {
           thePhi -= 360.;
         }
         unsigned int thePhiBin = (int)((thePhi + 180.) / binPhiW);
         if (thePhiBin == nphiBin) {
           thePhiBin -= 1;
         }
         nchvsphi[thePhiBin]++;
         sptvsphi[thePhiBin] += hepmcGPCollection[i]->momentum().perp();
         // analysis in the transverse region
         if (std::fabs(thePhi) > 60. && std::fabs(thePhi) < 120.) {
           nChaTra++;
           sptTra += hepmcGPCollection[i]->momentum().perp();
           binW = dNchdpt2->getTH1()->GetBinWidth(1);
           dNchdpt2->Fill(hepmcGPCollection[i]->momentum().perp(), 1. / binW);  // weight to account for the pt bin width
           binW = dNchdeta2->getTH1()->GetBinWidth(1);
           // weight to account for the eta bin width
           dNchdeta2->Fill(hepmcGPCollection[i]->momentum().eta(), 1. / binW);
         }
       }
     }
     nCha->Fill(nChaTra, weight);
     binW = dNchdSpt->getTH1()->GetBinWidth(1);
     dNchdSpt->Fill(sptTra, 1.);
     //how do one apply weights to a profile? MonitorElement doesn't allow to
     nChaDenLpt->Fill(hepmcGPCollection[iMax]->momentum().perp(), nChaTra / 4. / CLHEP::twopi);
     sptDenLpt->Fill(hepmcGPCollection[iMax]->momentum().perp(), sptTra / 4. / CLHEP::twopi);
     for (unsigned int i = 0; i < nphiBin; i++) {
       double thisPhi = -180. + (i + 0.5) * binPhiW;
       dNchdphi->Fill(thisPhi, nchvsphi[i] / binPhiW / 4.);  // density in phi and eta
       dSptdphi->Fill(thisPhi, sptvsphi[i] / binPhiW / 4.);  // density in phi and eta
     }
   }
 
   // Gather information in the charged GenJet collection
   edm::Handle<reco::GenJetCollection> genChJets;
   iEvent.getByToken(genchjetCollectionToken_, genChJets);
 
   unsigned int nJets = 0;
   double pt1 = 0.;
   double pt2 = 0.;
   reco::GenJetCollection::const_iterator ij1 = genChJets->begin();
   reco::GenJetCollection::const_iterator ij2 = genChJets->begin();
   if (sel2) {
     for (reco::GenJetCollection::const_iterator iter = genChJets->begin(); iter != genChJets->end(); ++iter) {
       double eta = (*iter).eta();
       double pt = (*iter).pt();
       if (verbosity_ > 0) {
         std::cout << "GenJet " << std::setw(14) << std::fixed << (*iter).pt() << std::setw(14) << std::fixed
                   << (*iter).eta() << std::setw(14) << std::fixed << (*iter).phi() << std::endl;
       }
       if (std::fabs(eta) < 2.) {
         nJets++;
         binW = dNchjdeta->getTH1()->GetBinWidth(1);
         dNchjdeta->Fill(eta, 1. / binW);
         binW = dNchjdpt->getTH1()->GetBinWidth(1);
         dNchjdpt->Fill(pt, 1. / binW);
         if (pt >= pt1) {
           pt1 = pt;
           ij1 = iter;
         }
         if (pt < pt1 && pt >= pt2) {
           pt2 = pt;
           ij2 = iter;
         }
       }
     }
 
     nChj->Fill(nJets, weight);
     if (nJets > 0 && ij1 != genChJets->end()) {
       leadChjpt->Fill(pt1, weight);
       leadChjeta->Fill((*ij1).eta(), weight);
       if (nJets > 1 && ij2 != genChJets->end()) {
         pt1pt2optotch->Fill(pt1 + pt2, (pt1 + pt2) / ptot);
       }
     }
   }
 
   // Gather information in the GenJet collection
   edm::Handle<reco::GenJetCollection> genJets;
   iEvent.getByToken(genjetCollectionToken_, genJets);
 
   nJets = 0;
   pt1 = 0.;
   pt2 = 0.;
   double pt3 = 0.;
 
   // needed for Jet-Multiplicity Analysis
   int jm25njets = 0;
   double jm25HT = 0.;
   double jm25pt1 = 0.;
   double jm25pt2 = 0.;
   double jm25pt3 = 0.;
   double jm25pt4 = 0.;
 
   int jm80njets = 0;
   double jm80HT = 0.;
   double jm80pt1 = 0.;
   double jm80pt2 = 0.;
   double jm80pt3 = 0.;
   double jm80pt4 = 0.;
 
   reco::GenJetCollection::const_iterator ij3 = genJets->begin();
   if (sel6) {
     for (reco::GenJetCollection::const_iterator iter = genJets->begin(); iter != genJets->end(); ++iter) {
       double eta = (*iter).eta();
       double pt = (*iter).pt();
       if (verbosity_ > 0) {
         std::cout << "GenJet " << std::setw(14) << std::fixed << (*iter).pt() << std::setw(14) << std::fixed
                   << (*iter).eta() << std::setw(14) << std::fixed << (*iter).phi() << std::endl;
       }
       if (std::fabs(eta) < 5.) {
         nJets++;
         if (pt >= pt1) {
           pt1 = pt;
           ij1 = iter;
         }
         if (pt < pt1 && pt >= pt2) {
           pt2 = pt;
           ij2 = iter;
         }
         if (pt < pt2 && pt >= pt3) {
           pt3 = pt;
           ij3 = iter;
         }
       }
 
       // find variables for Jet-Multiplicity Analysis
       if (fabs(iter->eta()) < 3. && iter->pt() > 25.) {
         jm25njets++;
         jm25HT += iter->pt();
         if (iter->pt() > jm25pt1) {
           jm25pt4 = jm25pt3;
           jm25pt3 = jm25pt2;
           jm25pt2 = jm25pt1;
           jm25pt1 = iter->pt();
         } else if (iter->pt() > jm25pt2) {
           jm25pt4 = jm25pt3;
           jm25pt3 = jm25pt2;
           jm25pt2 = iter->pt();
         } else if (iter->pt() > jm25pt3) {
           jm25pt4 = jm25pt3;
           jm25pt3 = iter->pt();
         } else if (iter->pt() > jm25pt4) {
           jm25pt4 = iter->pt();
         }
         // even harder jets...
         if (iter->pt() > 80.) {
           jm80njets++;
           jm80HT += iter->pt();
           if (iter->pt() > jm80pt1) {
             jm80pt4 = jm80pt3;
             jm80pt3 = jm80pt2;
             jm80pt2 = jm80pt1;
             jm80pt1 = iter->pt();
           } else if (iter->pt() > jm80pt2) {
             jm80pt4 = jm80pt3;
             jm80pt3 = jm80pt2;
             jm80pt2 = iter->pt();
           } else if (iter->pt() > jm80pt3) {
             jm80pt4 = jm80pt3;
             jm80pt3 = iter->pt();
           } else if (iter->pt() > jm80pt4) {
             jm80pt4 = iter->pt();
           }
         }
       }
     }
     if (jm25njets > 3) {
       _JM25njets->Fill(jm25njets, weight);
       _JM25ht->Fill(jm25HT, weight);
       _JM25pt1->Fill(jm25pt1, weight);
       _JM25pt2->Fill(jm25pt2, weight);
       _JM25pt3->Fill(jm25pt3, weight);
       _JM25pt4->Fill(jm25pt4, weight);
     }
     if (jm80njets > 3) {
       _JM80njets->Fill(jm80njets, weight);
       _JM80ht->Fill(jm80HT, weight);
       _JM80pt1->Fill(jm80pt1, weight);
       _JM80pt2->Fill(jm80pt2, weight);
       _JM80pt3->Fill(jm80pt3, weight);
       _JM80pt4->Fill(jm80pt4, weight);
     }
 
     // select a di-jet event JME-10-001 variant
     double sumJetEt = 0;
     double sumPartPt = 0.;
     double sumChPartPt = 0.;
     double jpx = 0;
     double jpy = 0;
     if (nJets >= 2 && ij1 != genJets->end() && ij2 != genJets->end()) {
       if ((*ij1).pt() > 25. && (*ij1).pt() > 25.) {
         double deltaPhi = std::fabs((*ij1).phi() - (*ij2).phi()) / CLHEP::degree;
         if (deltaPhi > 180.)
           deltaPhi = 360. - deltaPhi;
         pt1pt2Dphi->Fill(deltaPhi, weight);
         if (std::fabs(deltaPhi) > 2.5 * CLHEP::degree) {
           nDijet->Fill(0.5, weight);
 
           for (unsigned int i = 0; i < hepmcGPCollection.size(); i++) {
             double eta = hepmcGPCollection[i]->momentum().eta();
             unsigned int iBin = getHFbin(eta);
             if (!isNeutrino(i) && iBin < CaloCellManager::nForwardEta) {
               hfDJ[iBin] += hepmcGPCollection[i]->momentum().rho();
             }
             if (!isNeutrino(i) && std::fabs(eta) < 5.) {
               sumPartPt += hepmcGPCollection[i]->momentum().perp();
               if (isCharged(i)) {
                 sumChPartPt += hepmcGPCollection[i]->momentum().perp();
               }
             }
           }
           for (unsigned int i = 0; i < CaloCellManager::nForwardEta; i++) {
             binW = theEtaRanges[CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta + i + 1] -
                    theEtaRanges[CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta + i];
             dEdetaHFdj->Fill(i + 0.5, hfDJ[i] / binW);
           }
 
           double invMass = (*ij1).energy() * (*ij2).energy() - (*ij1).px() * (*ij2).px() - (*ij1).py() * (*ij2).py() -
                            (*ij1).pz() * (*ij2).pz();
           invMass = std::sqrt(invMass);
           pt1pt2InvM->Fill(invMass, weight);
 
           sumPt->Fill(sumPartPt, weight);
           sumChPt->Fill(sumChPartPt, weight);
 
           unsigned int nSelJets = 0;
           for (reco::GenJetCollection::const_iterator iter = genJets->begin(); iter != genJets->end(); ++iter) {
             double pt = (*iter).pt();
             double eta = (*iter).eta();
             if (std::fabs(eta) < 5.) {
               nSelJets++;
               binW = dNjdeta->getTH1()->GetBinWidth(1);
               dNjdeta->Fill(eta, 1. / binW * weight);
               binW = dNjdpt->getTH1()->GetBinWidth(1);
               dNjdpt->Fill(pt, 1. / binW * weight);
               sumJetEt += (*iter).pt();
               jpx += (*iter).px();
               jpy += (*iter).py();
             }
           }
 
           nj->Fill(nSelJets, weight);
           double mEt = std::sqrt(jpx * jpx + jpy * jpy);
           sumJEt->Fill(sumJetEt, weight);
           missEtosumJEt->Fill(mEt / sumJetEt, weight);
 
           if (nSelJets >= 3) {
             pt3Frac->Fill((*ij3).pt() / (pt1 + pt2), weight);
           }
 
           pt1pt2optot->Fill(pt1 + pt2, (pt1 + pt2) / sumJetEt);
           pt1pt2balance->Fill((pt1 - pt2) / (pt1 + pt2), weight);
         }
       }
     }
   }
 
   //compute differential jet rates
   std::vector<const HepMC::GenParticle*> qcdActivity;
   HepMCValidationHelper::removeIsolatedLeptons(myGenEvent, 0.2, 3., qcdActivity);
   //HepMCValidationHelper::allStatus1(myGenEvent, qcdActivity);
   //fill PseudoJets to use fastjet
   std::vector<fastjet::PseudoJet> vecs;
   int counterUser = 1;
   std::vector<const HepMC::GenParticle*>::const_iterator iqcdact;
   for (iqcdact = qcdActivity.begin(); iqcdact != qcdActivity.end(); ++iqcdact) {
     const HepMC::FourVector& fmom = (*iqcdact)->momentum();
     fastjet::PseudoJet pseudoJet(fmom.px(), fmom.py(), fmom.pz(), fmom.e());
     pseudoJet.set_user_index(counterUser);
     vecs.push_back(pseudoJet);
     ++counterUser;
   }
   //compute jets
   fastjet::ClusterSequence cseq(vecs, fastjet::JetDefinition(fastjet::kt_algorithm, 1., fastjet::E_scheme));
   //access the cluster sequence and get the relevant info
   djr10->Fill(std::log10(sqrt(cseq.exclusive_dmerge(0))), weight);
   djr21->Fill(std::log10(sqrt(cseq.exclusive_dmerge(1))), weight);
   djr32->Fill(std::log10(sqrt(cseq.exclusive_dmerge(2))), weight);
   djr43->Fill(std::log10(sqrt(cseq.exclusive_dmerge(3))), weight);
 
   // compute sumEt for all stable particles
   std::vector<const HepMC::GenParticle*> allStable;
   HepMCValidationHelper::allStatus1(myGenEvent, allStable);
 
   double sumEt = 0.;
   double sumEt1 = 0.;
   double sumEt2 = 0.;
   double sumEt3 = 0.;
   double sumEt4 = 0.;
   double sumEt5 = 0.;
 
   for (std::vector<const HepMC::GenParticle*>::const_iterator iter = allStable.begin(); iter != allStable.end();
        ++iter) {
     double thisEta = fabs((*iter)->momentum().eta());
 
     if (thisEta < 5.) {
       const HepMC::FourVector mom = (*iter)->momentum();
       double px = mom.px();
       double py = mom.py();
       double pz = mom.pz();
       double E = mom.e();
       double thisSumEt = (sqrt(px * px + py * py) * E / sqrt(px * px + py * py + pz * pz));
       sumEt += thisSumEt;
       if (thisEta < 1.0)
         sumEt1 += thisSumEt;
       else if (thisEta < 2.0)
         sumEt2 += thisSumEt;
       else if (thisEta < 3.0)
         sumEt3 += thisSumEt;
       else if (thisEta < 4.0)
         sumEt4 += thisSumEt;
       else
         sumEt5 += thisSumEt;
     }
   }
 
   if (sumEt > 0.)
     _sumEt->Fill(sumEt, weight);
   if (sumEt1 > 0.)
     _sumEt1->Fill(sumEt1, weight);
   if (sumEt2 > 0.)
     _sumEt2->Fill(sumEt2, weight);
   if (sumEt3 > 0.)
     _sumEt3->Fill(sumEt3, weight);
   if (sumEt4 > 0.)
     _sumEt4->Fill(sumEt4, weight);
   if (sumEt5 > 0.)
     _sumEt5->Fill(sumEt5, weight);
 
   delete myGenEvent;
 }  //analyze

◆ bookHistograms()

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

overridevirtual

Setting the DQM top directories

Booking the ME's

Implements DQMEDAnalyzer.

Definition at line 44 of file MBUEandQCDValidation.cc.

References _JM25ht, _JM25njets, _JM25pt1, _JM25pt2, _JM25pt3, _JM25pt4, _JM80ht, _JM80njets, _JM80pt1, _JM80pt2, _JM80pt3, _JM80pt4, _sumEt, _sumEt1, _sumEt2, _sumEt3, _sumEt4, _sumEt5, dEdetaHFdj, dEdetaHFmb, djr10, djr21, djr32, djr43, dNchdeta1, dNchdeta2, dNchdphi, dNchdpt1, dNchdpt2, dNchdSpt, dNchjdeta, dNchjdpt, dNjdeta, dNjdpt, dSptdphi, elePt, EmpzHFm, eneHFmSel, mps_fire::i, leadChjeta, leadChjpt, leadTracketa, leadTrackpt, missEtosumJEt, muoPt, nbquark, ncandbquark, nCha, nChaDenLpt, nChj, ncnobquark, nDijet, nEvt, nEvt1, nEvt2, CaloCellManager::nForwardEta, nGamma, nHFflow, nHFSD, nj, nK0s, nKpm, nL0, nNNbar, nNoFwdTrig, nOmega, nphiBin, nPPbar, nSaFwdTrig, ntHFm, nXim, pGamma, pK0s, pKpm, pL0, pNNbar, pOmega, pPPbar, pt1pt2balance, pt1pt2Dphi, pt1pt2InvM, pt1pt2optot, pt1pt2optotch, pt3Frac, pXim, sptDenLpt, sumChPt, sumJEt, and sumPt.

                                                                                                  {
   DQMHelper dqm(&i);
   i.setCurrentFolder("Generator/MBUEandQCD");
 
 
   // Number of analyzed events
   nEvt = dqm.book1dHisto("nEvt", "n analyzed Events", 1, 0., 1., " ", "Number of events");
 
   // Number of events with no forward trigger
   nNoFwdTrig = dqm.book1dHisto(
       "nNoFwdTrig", "n Events no forward trigger", 1, 0., 1., " ", "Number of Events with no Forward Trigger");
 
   // Number of Events with a single arm forward trigger
   nSaFwdTrig = dqm.book1dHisto("nSaFwdTrig",
                                "n Events single arm forward trigger",
                                1,
                                0.,
                                1.,
                                " ",
                                "Number of Events with Single Arm Forward Trigger");
 
   // Number of Events with b quark
   nbquark = dqm.book1dHisto("nbquark", "n Events with b quark", 1, 0., 1., " ", "Number of Events with b Quarks");
 
   // Number of Events with c and b quark
   ncandbquark = dqm.book1dHisto(
       "ncandbquark", "n Events with c and b quark", 1, 0., 1., "", "Number of Events with c and b Quark");
 
   // Number of Events with c and no b quark
   ncnobquark = dqm.book1dHisto(
       "ncnobquark", "n Events with c and no b quark", 1, 0., 1., "", "Number of Events with c and no b Quark");
 
   // Number of selected events for QCD-09-010
   nEvt1 = dqm.book1dHisto(
       "nEvt1", "n Events QCD-09-010", 1, 0., 1., "", "Number of Events passing the QCD-09-010 selection");
   // dNchdpt QCD-09-010
   dNchdpt1 = dqm.book1dHisto("dNchdpt1",
                              "dNchdpt QCD-09-010",
                              30,
                              0.,
                              6.,
                              "P_{t}^{charged tracks QCD-09-010 selection} (GeV)",
                              "Number of Charged Tracks");
   // dNchdeta QCD-09-010
   dNchdeta1 = dqm.book1dHisto("dNchdeta1",
                               "dNchdeta QCD-09-010",
                               10,
                               -2.5,
                               2.5,
                               "#eta^{charged tracks QCD-09-010 selection}",
                               "Number of Charged Tracks");
   // Number of selected events for QCD-10-001
 
   nEvt2 = dqm.book1dHisto(
       "nEvt2", "n Events QCD-10-001", 1, 0., 1., "", "Number of Events passing the QCD-10-001 selection");
   // Leading track pt QCD-10-001
   leadTrackpt = dqm.book1dHisto("leadTrackpt",
                                 "leading track pt QCD-10-001",
                                 200,
                                 0.,
                                 100.,
                                 "P_{t}^{lead track QCD-10-001 selection} (GeV)",
                                 "Number of Events");
   // Leading track eta QCD-10-001
   leadTracketa = dqm.book1dHisto("leadTracketa",
                                  "leading track eta QCD-10-001",
                                  50.,
                                  -2.5,
                                  2.5,
                                  "#eta^{lead track QCD-10-001 selection}",
                                  "Number of Events");
   // transverse charged particle density vs leading track pt
   nChaDenLpt = i.bookProfile("nChaDenLpt", "charged density vs leading pt", 200, 0., 100., 0., 100., " ");
   // transverse charged particle density vs leading track pt
   sptDenLpt = i.bookProfile("sptDenLpt", "sum pt density vs leading pt", 200, 0., 100., 0., 300., " ");
   // dNchdpt QCD-10-001 transverse
   dNchdpt2 = dqm.book1dHisto("dNchdpt2",
                              "dNchdpt QCD-10-001",
                              200,
                              0.,
                              100.,
                              "P_{t}^{charged tracks QCD-10-001 selection} (GeV)",
                              "Number of Charged Tracks");
   // dNchdeta QCD-10-001 transverse
   dNchdeta2 = dqm.book1dHisto("dNchdeta2",
                               "dNchdeta QCD-10-001",
                               50,
                               -2.5,
                               2.5,
                               "#eta^{charged tracks QCD-10-001 selection}",
                               "Number of Charged Tracks");
   // nCha QCD-10-001 transverse
   nCha = dqm.book1dHisto(
       "nCha", "n charged QCD-10-001", 100, 0., 100., "N^{charged tracks QCD-10-001 selection}", "Number of Events");
   // dNchdSpt transverse
   dNchdSpt = dqm.book1dHisto("dNchdSpt",
                              "dNchdSpt QCD-10-001",
                              300,
                              0.,
                              300.,
                              "P_{t}^{charged trackes in transverse region QCD-10-001selection} (GeV)",
                              "Number of Charged Tracks");
   // dNchdphi
   dNchdphi = i.bookProfile("dNchdphi", "dNchdphi QCD-10-001", nphiBin, -180., 180., 0., 30., " ");
   // dSptdphi
   dSptdphi = i.bookProfile("dSptdphi", "dSptdphi QCD-10-001", nphiBin, -180., 180., 0., 30., " ");
 
   // number of charged jets QCD-10-001
   nChj = dqm.book1dHisto(
       "nChj", "n charged jets QCD-10-001", 30, 0, 30., "N^{charged jets QCD-10-001 selection}", "Number of Events");
   // dNchjdeta QCD-10-001
   dNchjdeta = dqm.book1dHisto("dNchjdeta",
                               "dNchjdeta QCD-10-001",
                               50,
                               -2.5,
                               2.5,
                               "#eta^{charged jets QCD-10-001 selection}",
                               "Number of charged Jets");
   // dNchjdpt QCD-10-001
   dNchjdpt = dqm.book1dHisto("dNchjdpt",
                              "dNchjdpt QCD-10-001",
                              100,
                              0.,
                              100.,
                              "P_{t}^{charged jets QCD-10-001 selection}",
                              "Number of charged Jets");
   // leading charged jet pt QCD-10-001
   leadChjpt = dqm.book1dHisto("leadChjpt",
                               "leadChjpt QCD-10-001",
                               100,
                               0.,
                               100.,
                               "P_{t}^{lead charged jet QCD-10-001 selection}",
                               "Number of charged Jets");
   // leading charged jet eta QCD-10-001
   leadChjeta = dqm.book1dHisto("leadChjeta",
                                "leadChjeta QCD-10-001",
                                50,
                                -2.5,
                                2.5,
                                "#eta^{lead charged jet QCD-10-001 selection}",
                                "Number of charged Jets");
   // (pt1+pt2)/ptot
   pt1pt2optotch = i.bookProfile("pt1pt2optotch", "sum 2 leading jets over ptot", 50, 0., 100., 0., 1., " ");
 
   // particle rates in tracker acceptance
   nPPbar = dqm.book1dHisto(
       "nPPbar", "nPPbar QCD-10-001", 30, 0., 30., "N_{p/#bar{p}}^{QCD-10-001 selection}", "Number of p/#bar{p}");
   nKpm = dqm.book1dHisto(
       "nKpm", "nKpm QCD-10-001", 30, 0., 30., "N_{K^{#pm}}^{QCD-10-001 selection}", "Number of K^{#pm}");
   nK0s = dqm.book1dHisto("nK0s", "nK0s QCD-10-001", 30, 0., 30., "N_{K^{0}}^{QCD-10-001 selection}", "Number of K^{0}");
   nL0 = dqm.book1dHisto(
       "nL0", "nL0 QCD-10-001", 30, 0., 30., "N_{#Lambda^{0}}^{QCD-10-001 selection}", "Number of #Lambda^{0}");
   nXim = dqm.book1dHisto("nXim", "nXim QCD-10-001", 30, 0., 30., "N_{#Xi}^{QCD-10-001 selection}", "Number of #Xi");
   nOmega = dqm.book1dHisto(
       "nOmega", "nOmega QCD-10-001", 30, 0., 30., "N_{#Omega^{#pm}}^{QCD-10-001 selection}", "Number of #Omega^{#pm}");
 
   pPPbar = dqm.book1dHisto("pPPbar",
                            "Log10(pt) PPbar QCD-10-001",
                            25,
                            -2.,
                            3.,
                            "log_{10}(P_{t}^{p/#bar{p} QCD-10-001 selection}) (log_{10}(GeV))",
                            "Number of p/#bar{p}");
   pKpm = dqm.book1dHisto("pKpm",
                          "Log10(pt) Kpm QCD-10-001",
                          25,
                          -2.,
                          3.,
                          "log_{10}(P_{t}^{K^{#pm} QCD-10-001 selection}) (log_{10}(GeV))",
                          "Number of K^{#pm}");
   pK0s = dqm.book1dHisto("pK0s",
                          "Log10(pt) K0s QCD-10-001",
                          25,
                          -2.,
                          3.,
                          "log_{10}(P_{t}^{K^{0} QCD-10-001 selection}) (log_{10}(GeV))",
                          "Number of K^{0}");
   pL0 = dqm.book1dHisto("pL0",
                         "Log10(pt) L0 QCD-10-001",
                         25,
                         -2.,
                         3.,
                         "log_{10}(P_{t}^{#Lambda^{0} QCD-10-001 selection}) (log_{10}(GeV))",
                         "Number of #Lambda^{0}");
   pXim = dqm.book1dHisto("pXim",
                          "Log10(pt) Xim QCD-10-001",
                          25,
                          -2.,
                          3.,
                          "log_{10}(P_{t}^{#Xi^{#pm} QCD-10-001 selection}) (log_{10}(GeV))",
                          "Number of #Xi");
   pOmega = dqm.book1dHisto("pOmega",
                            "Log10(pt) Omega QCD-10-001",
                            25,
                            -2.,
                            3.,
                            "log_{10}(P_{t}^{#Omega^{#pm} QCD-10-001 selection}) (log_{10}(GeV))",
                            "Number of #Omega^{#pm}");
 
   // neutral rate in the barrel + HF acceptance
   nNNbar = dqm.book1dHisto(
       "nNNbar", "nNNbar QCD-10-001", 30, 0., 30., "N_{n/#bar{n}}^{QCD-10-001 selection}", "Number of Events");
   nGamma = dqm.book1dHisto(
       "nGamma", "nGamma QCD-10-001", 50, 0., 200., "N_{#gamma}^{QCD-10-001 selection}", "Number of Events");
 
   pNNbar = dqm.book1dHisto("pNNbar",
                            "Log10(pt) NNbar QCD-10-001",
                            25,
                            -2.,
                            3.,
                            "log_{10}(P_{t}^{n/#bar{n} QCD-10-001 selection}) (log_{10}(GeV))",
                            "Number of n/#bar{n}");
   pGamma = dqm.book1dHisto("pGamma",
                            "Log10(pt) Gamma QCD-10-001",
                            25,
                            -2.,
                            3.,
                            "log_{10}(P_{t}^{#gamma QCD-10-001 selection}) (log_{10}(GeV))",
                            "Number of #gamma");
 
   // highest pt electron spectrum
   elePt = dqm.book1dHisto("elePt",
                           "highest pt electron Log10(pt)",
                           30,
                           -2.,
                           4.,
                           "log_{10}(P_{t}^{highest e} (log_{10}(GeV))",
                           "Number of Events");
 
   // highest pt muon spectrum
   muoPt = dqm.book1dHisto("muoPt",
                           "highest pt muon Log10(pt)",
                           30,
                           -2.,
                           4.,
                           "log_{10}(P_{t}^{highest #mu}  (log_{10}(GeV))",
                           "Number of Events");
 
   // number of selected di-jet events
   nDijet = dqm.book1dHisto(
       "nDijet", "n Dijet Events", 1, 0., 1., " ", "Number of Events Passing Di-jet JME-10-001 Selection");
   // number of jets
   nj = dqm.book1dHisto("nj", "n jets ", 30, 0, 30., "N_{jets}^{JME-10-001}", "Number of Events");
   // dNjdeta
   dNjdeta = dqm.book1dHisto("dNjdeta", "dNjdeta ", 50, -5., 5., "#eta_{jets}^{JME-10-001 selection}", "Number of Jets");
   // dNjdpt
   dNjdpt = dqm.book1dHisto("dNjdpt", "dNjdpt ", 60, 0., 300., "P_{t}^{jets JME-10-001 selection}", "Number of Jets");
   // (pt1+pt2)/ptot
   pt1pt2optot = i.bookProfile("pt1pt2optot", "sum 2 leading jets over Et tot ", 60, 0., 300., 0., 1., " ");
   // pt1-pt2
   pt1pt2balance =
       dqm.book1dHisto("pt1pt2balance",
                       "2 leading jets pt difference ",
                       10,
                       0.,
                       1.,
                       "#frac{P_{t}^{1st jet}-P_{t}^{2nd jet}}{P_{t}^{1st jet}+P_{t}^{2nd jet}}^{JME-10-001 selection}",
                       "Number of Di-jet Events");
   // pt1 pt2 Delta phi
   pt1pt2Dphi = dqm.book1dHisto("pt1pt2Dphi",
                                "pt1 pt2 delta phi ",
                                nphiBin,
                                0.,
                                180.,
                                "#Delta#phi(jet^{1st},jet^{2nd})^{JME-10-001 selection} (rad)",
                                "Number of Di-jet Events");
   // pt1 pt2 invariant mass
   pt1pt2InvM = dqm.book1dHisto("pt1pt2InvM",
                                "pt1 pt2 invariant mass ",
                                60,
                                0.,
                                600.,
                                "M_{di-jet}^{JME-10-001 selection}",
                                "Number of di-jet events");
   // pt3 fraction
   pt3Frac = dqm.book1dHisto("pt3Frac",
                             "2 pt3 over pt1+pt2 ",
                             30,
                             0.,
                             1.,
                             "#frac{P_{t}^{3rd jet}}{P_{t}^{1st jet}+P_{t}^{2nd jet}}^{JME-10-001 selection}",
                             "Number of 3rd Jets");
   // sum of jets Et
   sumJEt = dqm.book1dHisto(
       "sumJEt", "sum Jet Et ", 60, 0., 300., "#Sigma E_{t}^{jets JME-10-001 selection}", "Number of di-jet events");
   // fraction of missing Et over sum of jets Et
   missEtosumJEt = dqm.book1dHisto("missEtosumJEt",
                                   "missing Et over sumJet Et ",
                                   30,
                                   0.,
                                   1.,
                                   "E_{t}^{miss}/#Sigma E_{t}^{jets JME-10-001 selection}",
                                   "Number of Di-jet Events");
   // sum of final state particle Pt
   sumPt = dqm.book1dHisto("sumPt",
                           "sum particle Pt ",
                           60,
                           0.,
                           600.,
                           "#Sigma P_{t}^{particles passing JME-10-001 selection}",
                           "Number of jets");
   // sum of final state charged particle Pt
   sumChPt = dqm.book1dHisto("sumChPt",
                             "sum charged particle Pt ",
                             60,
                             0.,
                             300.,
                             "#Sigma P_{t}^{charged particles passing JME-10-001 selection}",
                             "Number of Jets");
 
   //Number of selected events for the HF energy flux analysis
   nHFflow = dqm.book1dHisto("nHFflow",
                             "n HF flow events",
                             1,
                             0.,
                             1.,
                             " ",
                             "Number of Events passing JME-10-001, FWD-10-002 and Jet-Multiplicity selection");
   //Forward energy flow for MinBias BSC selection
   dEdetaHFmb = i.bookProfile("dEdetaHFmb",
                              "dEdeta HF MinBias",
                              (int)CaloCellManager::nForwardEta,
                              0,
                              (double)CaloCellManager::nForwardEta,
                              0.,
                              300.,
                              " ");
   //Forward energy flow for QCD dijet selection
   dEdetaHFdj = i.bookProfile("dEdetaHFdj",
                              "dEdeta HF QCD dijet",
                              (int)CaloCellManager::nForwardEta,
                              0,
                              (double)CaloCellManager::nForwardEta,
                              0.,
                              300.,
                              " ");
 
   // FWD-10-001 like diffraction analysis
   nHFSD = dqm.book1dHisto(
       "nHFSD", "n single diffraction in HF", 1, 0., 1., " ", "Number of single diffraction in HF FWD-10-001 selection");
   // E-pz HF-
   EmpzHFm = dqm.book1dHisto("EmpzHFm",
                             "E-pz HF- SD",
                             40,
                             0.,
                             200.,
                             "#Sigma E_{cal. cells/corrected for the longitudinal mometum}^{FWD-10-001 selection}",
                             "Number of Events");
   // Number of cells above threshold
   ntHFm = dqm.book1dHisto("ntHFm",
                           "number of HF- tower SD",
                           20,
                           0.,
                           20.,
                           " N_{cells over threshold for single diffraction in HF Towers}^{FWD-10-001 selection}",
                           "Number of Events");
   // Energy in HF-
   eneHFmSel = dqm.book1dHisto(
       "eneHFmSel", "energy in HF-", 40, 0., 200., "#Sigma E_{cal. cells}^{FWD-10-001 selection}", "Number of Events");
 
   // number of jets accepted in the 'Jet-Multiplicity' analysis
   _JM25njets = dqm.book1dHisto("JM25njets", "n jets", 15, 0, 15., "Number of JM25 Jets", "Number of Events");
   _JM25ht = dqm.book1dHisto("JM25ht", "HT", 80, 0, 800., "H_{t}^{JM25} (GeV)", "Number of Events");
   _JM25pt1 = dqm.book1dHisto("JM25pt1", "pt", 40, 0, 200., "P_{t}^{JM25,1st Jet} (GeV)", "Number of JM25 Jets");
   _JM25pt2 = dqm.book1dHisto("JM25pt2", "pt", 40, 0, 200., "P_{t}^{JM25,2nd Jet} (GeV)", "Number of JM25 Jets");
   _JM25pt3 = dqm.book1dHisto("JM25pt3", "pt", 40, 0, 200., "P_{t}^{JM25,3rd Jet} (GeV)", "Number of JM25 Jets");
   _JM25pt4 = dqm.book1dHisto("JM25pt4", "pt", 40, 0, 200., "P_{t}^{JM25,4th Jet} (GeV)", "Number of JM25 Jets");
 
   _JM80njets = dqm.book1dHisto("JM80njets", "n jets", 15, 0, 15., "Number of JM80 Jets", "Number of Events");
   _JM80ht = dqm.book1dHisto("JM80ht", "HT", 80, 300, 1100., "H_{t}^{JM80} (GeV", "Number of Events");
   _JM80pt1 = dqm.book1dHisto("JM80pt1", "pt", 40, 60, 260., "P_{t}^{JM80,1st Jet} (GeV)", "Number of JM80 Jets");
   _JM80pt2 = dqm.book1dHisto("JM80pt2", "pt", 40, 60, 260., "P_{t}^{JM80,2nd Jet} (GeV)", "Number of JM80 Jets");
   _JM80pt3 = dqm.book1dHisto("JM80pt3", "pt", 40, 60, 260., "P_{t}^{JM80,3rd Jet} (GeV)", "Number of JM80 Jets");
   _JM80pt4 = dqm.book1dHisto("JM80pt4", "pt", 40, 60, 260., "P_{t}^{JM80,4th Jet} (GeV)", "Number of JM80 Jets");
 
   // differential jet rates
   djr10 = dqm.book1dHisto("djr10",
                           "Differential Jet Rate 1#rightarrow0",
                           60,
                           -1.,
                           5.,
                           "log_{10}(d_{min}(n,n+1)) for n=0",
                           "Number of Events");
   djr21 = dqm.book1dHisto("djr21",
                           "Differential Jet Rate 2#rightarrow1",
                           60,
                           -1.,
                           5.,
                           "log_{10}(d_{min}(n,n+1)) for n=1",
                           "Number of Events");
   djr32 = dqm.book1dHisto("djr32",
                           "Differential Jet Rate 3#rightarrow2",
                           60,
                           -1.,
                           5.,
                           "log_{10}(d_{min}(n,n+1)) for n=2",
                           "Number of Events");
   djr43 = dqm.book1dHisto("djr43",
                           "Differential Jet Rate 4#rightarrow3",
                           60,
                           -1.,
                           5.,
                           "log_{10}(d_{min}(n,n+1)) for n=3",
                           "Number of Events");
 
   // sumET analysis
   _sumEt = dqm.book1dHisto(
       "sumET", "Sum of stable particles Et", 150, 0, 600., "#Sigma E_{t}^{stable particles}", "Number of Events");
   _sumEt1 = dqm.book1dHisto("sumET1",
                             "Sum of stable particles Et (eta<0.5)",
                             150,
                             0,
                             200.,
                             "#Sigma E_{t}^{stable particles (#eta<0.5)}",
                             "Number of Events");
   _sumEt2 = dqm.book1dHisto("sumET2",
                             "Sum of stable particles Et (0.5<eta<1.0)",
                             150,
                             0,
                             200.,
                             "#Sigma E_{t}^{stable particles (0.5<#eta<1.0)}",
                             "Number of Events");
   _sumEt3 = dqm.book1dHisto("sumET3",
                             "Sum of stable particles Et (1.0<eta<1.5)",
                             150,
                             0,
                             200.,
                             "#Sigma E_{t}^{stable particles (1.0<#eta<1.5)}",
                             "Number of Events");
   _sumEt4 = dqm.book1dHisto("sumET4",
                             "Sum of stable particles Et (1.5<eta<2.0)",
                             150,
                             0,
                             200.,
                             "#Sigma E_{t}^{stable particles (1.5<#eta<2.0)}",
                             "Number of Events");
   _sumEt5 = dqm.book1dHisto("sumET5",
                             "Sum of stable particles Et (2.0<eta<5.0)",
                             150,
                             0,
                             200.,
                             "#Sigma E_{t}^{stable particles (2.0<#eta<5.0)}",
                             "Number of Events");
 
   return;
 }

◆ dqmBeginRun()

void MBUEandQCDValidation::dqmBeginRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 40 of file MBUEandQCDValidation.cc.

References HltBtagPostValidation_cff::c, fPDGTable, and fPDGTableToken.

                                                                               {
   fPDGTable = c.getHandle(fPDGTableToken);
 }

◆ getHFbin()

unsigned int MBUEandQCDValidation::getHFbin ( double eta )

private

Definition at line 1174 of file MBUEandQCDValidation.cc.

References PVValHelper::eta, CaloCellManager::getEtaRanges(), mps_fire::i, CaloCellManager::nBarrelEta, CaloCellManager::nEndcapEta, CaloCellManager::nForwardEta, and theCalo.

Referenced by analyze().

                                                       {
   unsigned int iBin = 999;
 
   std::vector<double> theEtaRanges(theCalo->getEtaRanges());
 
   for (unsigned int i = CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta;
        i < CaloCellManager::nBarrelEta + CaloCellManager::nEndcapEta + CaloCellManager::nForwardEta;
        i++) {
     if (std::fabs(eta) >= theEtaRanges[i] && std::fabs(eta) < theEtaRanges[i + 1]) {
       iBin = i - CaloCellManager::nBarrelEta - CaloCellManager::nEndcapEta;
     }
   }
 
   return iBin;
 }

◆ isCharged()

bool MBUEandQCDValidation::isCharged ( unsigned int i )

private

Definition at line 1142 of file MBUEandQCDValidation.cc.

References hepmcCharge, hepmcGPCollection, mps_fire::i, and mps_update::status.

Referenced by analyze().

                                                    {
   bool status = false;
   if (hepmcGPCollection.size() < i + 1) {
     return status;
   } else {
     status = (hepmcCharge[i] != 0. && hepmcCharge[i] != -999.);
   }
   return status;
 }

◆ isNeutral()

bool MBUEandQCDValidation::isNeutral ( unsigned int i )

private

Definition at line 1152 of file MBUEandQCDValidation.cc.

References funct::abs(), hepmcCharge, hepmcGPCollection, mps_fire::i, HiggsValidation_cfi::pdg_id, EgammaValidation_cff::pdgId, and mps_update::status.

Referenced by analyze().

                                                    {
   bool status = false;
   int pdgId = std::abs(hepmcGPCollection[i]->pdg_id());
   if (hepmcGPCollection.size() < i + 1) {
     return status;
   } else {
     status = (hepmcCharge[i] == 0. && pdgId != 12 && pdgId != 14 && pdgId != 16);
   }
   return status;
 }

◆ isNeutrino()

bool MBUEandQCDValidation::isNeutrino ( unsigned int i )

private

Definition at line 1163 of file MBUEandQCDValidation.cc.

References funct::abs(), hepmcGPCollection, mps_fire::i, HiggsValidation_cfi::pdg_id, EgammaValidation_cff::pdgId, and mps_update::status.

Referenced by analyze().

                                                     {
   bool status = false;
   int pdgId = std::abs(hepmcGPCollection[i]->pdg_id());
   if (hepmcGPCollection.size() < i + 1) {
     return status;
   } else {
     status = (pdgId == 12 || pdgId == 14 || pdgId == 16);
   }
   return status;
 }