#include <BasicHepMCValidation.h>

Inheritance diagram for BasicHepMCValidation:

Classes
class	ParticleMonitor

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

	BasicHepMCValidation (const edm::ParameterSet &)

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

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

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

virtual void	dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

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

	DQMEDAnalyzer ()

virtual void	dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

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

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

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

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

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
MonitorElement *	Bjorken_x

MonitorElement *	DeltaEcms

MonitorElement *	DeltaPx

MonitorElement *	DeltaPy

MonitorElement *	DeltaPz

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

MonitorElement *	genPtclNumber

MonitorElement *	genPtclStatus

MonitorElement *	genVrtxNumber

edm::InputTag	hepmcCollection_

edm::EDGetTokenT< edm::HepMCProduct >	hepmcCollectionToken_

MonitorElement *	log10DeltaEcms

MonitorElement *	nEvt

MonitorElement *	otherPtclMomentum

MonitorElement *	otherPtclNumber
	other ME's More...

MonitorElement *	outVrtxPtclNumber

MonitorElement *	outVrtxStablePtclNumber

std::vector< ParticleMonitor >	particles

MonitorElement *	parton1Id

MonitorElement *	parton2Id

MonitorElement *	partonNumber

MonitorElement *	partonpT

MonitorElement *	pdf_bbbar

MonitorElement *	pdf_ccbar

MonitorElement *	pdf_d

MonitorElement *	pdf_dbar

MonitorElement *	pdf_g

MonitorElement *	pdf_ssbar

MonitorElement *	pdf_u

MonitorElement *	pdf_ubar

MonitorElement *	scalePDF

MonitorElement *	stableChaNumber

MonitorElement *	stablePtclCharge

MonitorElement *	stablePtclEta

MonitorElement *	stablePtclNumber

MonitorElement *	stablePtclp

MonitorElement *	stablePtclPhi

MonitorElement *	stablePtclpT

MonitorElement *	status1ShortLived

MonitorElement *	unknownPDTNumber

MonitorElement *	vrtxRadius

MonitorElement *	vrtxZ

WeightManager	wmanager_

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

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 34 of file BasicHepMCValidation.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 14 of file BasicHepMCValidation.cc.

References hepmcCollection_, and hepmcCollectionToken_.

     : wmanager_(iPSet, consumesCollector()), hepmcCollection_(iPSet.getParameter<edm::InputTag>("hepmcCollection")) {
   hepmcCollectionToken_ = consumes<HepMCProduct>(hepmcCollection_);
 }

BasicHepMCValidation::~BasicHepMCValidation ( )

override

Definition at line 19 of file BasicHepMCValidation.cc.

19 {}

Member Function Documentation

void BasicHepMCValidation::analyze	(	edm::Event const &	,
		edm::EventSetup const &
	)

overridevirtual

counters to zero for every event

Gathering the HepMCProduct information

PDF informations

Vertices

loop on vertex particles

Looping through the PARTICLES in the event

Particles

Status statistics

Stable particles

filling multiplicity ME's

Reimplemented from DQMEDAnalyzer.

Definition at line 274 of file BasicHepMCValidation.cc.

References funct::abs(), Bjorken_x, ALCARECOTkAlJpsiMuMu_cff::charge, DeltaEcms, DeltaPx, DeltaPy, DeltaPz, dqm::impl::MonitorElement::Fill(), fPDGTable, GenParticle::GenParticle, genPtclNumber, genPtclStatus, genVrtxNumber, edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), hepmcCollectionToken_, mps_fire::i, log10DeltaEcms, logPdfBinsize, logPdfMax, logPdfMin, logQScaleBinsize, nEvt, otherPtclMomentum, otherPtclNumber, outVrtxPtclNumber, outVrtxStablePtclNumber, LHEGenericFilter_cfi::ParticleID, particles, parton1Id, parton2Id, partonNumber, partonpT, pdf_bbbar, pdf_ccbar, pdf_d, pdf_dbar, pdf_g, pdf_ssbar, pdf_u, pdf_ubar, scalePDF, stableChaNumber, stablePtclCharge, stablePtclEta, stablePtclNumber, stablePtclp, stablePtclPhi, stablePtclpT, mps_update::status, status1ShortLived, unknownPDTNumber, vrtxRadius, vrtxZ, WeightManager::weight(), mps_merge::weight, and wmanager_.

                                                                                       {
   int partonNum = 0;
   //
   int outVrtxStablePtclNum = 0;
   int stablePtclNum = 0;
   int otherPtclNum = 0;
   int unknownPDTNum = 0;
   int stableChaNum = 0;
   //
   double bjorken = 0.;
   double logPdf1 = 0.;
   double logPdf2 = 0.;
   double logQScale = 0.;
   //
   double etotal = 0.;
   double pxtotal = 0.;
   double pytotal = 0.;
   double pztotal = 0.;
 
   edm::Handle<HepMCProduct> evt;
   iEvent.getByToken(hepmcCollectionToken_, evt);
 
   //Get EVENT
   HepMC::GenEvent const *myGenEvent = evt->GetEvent();
 
   double weight = wmanager_.weight(iEvent);
 
   nEvt->Fill(0.5, weight);
 
   genPtclNumber->Fill(log10(myGenEvent->particles_size()), weight);
   genVrtxNumber->Fill(log10(myGenEvent->vertices_size()), weight);
 
   HepMC::PdfInfo const *pdf = myGenEvent->pdf_info();
   if (pdf) {
     bjorken = ((pdf->x1()) / ((pdf->x1()) + (pdf->x2())));
     logQScale = log10(pdf->scalePDF());
     if (logQScale > logQScaleMax)
       logQScale = logQScaleMax - 0.5 * logQScaleBinsize;  // visualize overflow & underflow in the histograms
     if (logQScale < logQScaleMin)
       logQScale = logQScaleMin + 0.5 * logQScaleBinsize;
     logPdf1 = log10(pdf->pdf1());
     if (logPdf1 > logPdfMax)
       logPdf1 = logPdfMax - 0.5 * logPdfBinsize;
     if (logPdf1 < logPdfMin)
       logPdf1 = logPdfMin + 0.5 * logPdfBinsize;
     logPdf2 = log10(pdf->pdf2());
     if (logPdf2 > logPdfMax)
       logPdf2 = logPdfMax - 0.5 * logPdfBinsize;
     if (logPdf2 < logPdfMin)
       logPdf2 = logPdfMin + 0.5 * logPdfBinsize;
     Bjorken_x->Fill(bjorken, weight);
     scalePDF->Fill(logQScale, weight);
     parton1Id->Fill((double)pdf->id1(), weight);
     parton2Id->Fill((double)pdf->id2(), weight);
     if (pdf->id1() == 2)
       pdf_u->Fill(logPdf1, weight);
     if (pdf->id2() == 2)
       pdf_u->Fill(logPdf2, weight);
     if (pdf->id1() == -2)
       pdf_ubar->Fill(logPdf1, weight);
     if (pdf->id2() == -2)
       pdf_ubar->Fill(logPdf2, weight);
     if (pdf->id1() == 1)
       pdf_d->Fill(logPdf1, weight);
     if (pdf->id2() == 1)
       pdf_d->Fill(logPdf2, weight);
     if (pdf->id1() == -1)
       pdf_dbar->Fill(logPdf1, weight);
     if (pdf->id2() == -1)
       pdf_dbar->Fill(logPdf2, weight);
     if (std::abs(pdf->id1()) == 3)
       pdf_ssbar->Fill(logPdf1, weight);
     if (std::abs(pdf->id2()) == 3)
       pdf_ssbar->Fill(logPdf2, weight);
     if (std::abs(pdf->id1()) == 4)
       pdf_ccbar->Fill(logPdf1, weight);
     if (std::abs(pdf->id2()) == 4)
       pdf_ccbar->Fill(logPdf2, weight);
     if (std::abs(pdf->id1()) == 5)
       pdf_bbbar->Fill(logPdf1, weight);
     if (std::abs(pdf->id2()) == 5)
       pdf_bbbar->Fill(logPdf2, weight);
     if (std::abs(pdf->id1()) == 21)
       pdf_g->Fill(logPdf1, weight);
     if (std::abs(pdf->id2()) == 21)
       pdf_g->Fill(logPdf2, weight);
   }
 
   //Looping through the VERTICES in the event
   HepMC::GenEvent::vertex_const_iterator vrtxBegin = myGenEvent->vertices_begin();
   HepMC::GenEvent::vertex_const_iterator vrtxEnd = myGenEvent->vertices_end();
   unsigned int nvtx(0);
   for (HepMC::GenEvent::vertex_const_iterator vrtxIt = vrtxBegin; vrtxIt != vrtxEnd; ++vrtxIt) {
     HepMC::GenVertex const *vrtx = *vrtxIt;
     outVrtxPtclNumber->Fill(vrtx->particles_out_size(), weight);
     //std::cout << "all " << vrtx->particles_out_size() << '\n';
 
     if (nvtx == 0) {
       vrtxZ->Fill(vrtx->point3d().z(), weight);
       vrtxRadius->Fill(vrtx->point3d().perp(), weight);
     }
     HepMC::GenVertex::particles_out_const_iterator vrtxPtclBegin = vrtx->particles_out_const_begin();
     HepMC::GenVertex::particles_out_const_iterator vrtxPtclEnd = vrtx->particles_out_const_end();
     outVrtxStablePtclNum = 0;
     for (HepMC::GenVertex::particles_out_const_iterator vrtxPtclIt = vrtxPtclBegin; vrtxPtclIt != vrtxPtclEnd;
          ++vrtxPtclIt) {
       HepMC::GenParticle const *vrtxPtcl = *vrtxPtclIt;
       if (vrtxPtcl->status() == 1) {
         ++outVrtxStablePtclNum;
         //std::cout << "stable " << outVrtxStablePtclNum << '\n';
       }
     }
     outVrtxStablePtclNumber->Fill(outVrtxStablePtclNum, weight);
     nvtx++;
   }  //vertices
 
   HepMC::GenEvent::particle_const_iterator ptclBegin = myGenEvent->particles_begin();
   HepMC::GenEvent::particle_const_iterator ptclEnd = myGenEvent->particles_end();
   for (HepMC::GenEvent::particle_const_iterator ptclIt = ptclBegin; ptclIt != ptclEnd; ++ptclIt) {
     HepMC::GenParticle const *ptcl = *ptclIt;
     int Id = ptcl->pdg_id();  // std::cout << Id << '\n';
     float Log_p = log10(ptcl->momentum().rho());
     double charge = 999.;  // for the charge it's needed a HepPDT method
     int status = ptcl->status();
     const HepPDT::ParticleData *PData = fPDGTable->particle(HepPDT::ParticleID(Id));
     if (PData == nullptr) {
       //        std::cout << "Unknown id = " << Id << '\n';
       ++unknownPDTNum;
     } else
       charge = PData->charge();
 
     genPtclStatus->Fill((float)status, weight);
 
     if (ptcl->status() == 1) {
       ++stablePtclNum;
       stablePtclPhi->Fill(ptcl->momentum().phi() / CLHEP::degree,
                           weight);  //std::cout << ptcl->polarization().phi() << '\n';
       stablePtclEta->Fill(ptcl->momentum().pseudoRapidity(), weight);
       stablePtclCharge->Fill(charge, weight);  // std::cout << ptclData.charge() << '\n';
       stablePtclp->Fill(Log_p, weight);
       stablePtclpT->Fill(log10(ptcl->momentum().perp()), weight);
       if (charge != 0. && charge != 999.)
         ++stableChaNum;
       if (std::abs(Id) == 1)
         status1ShortLived->Fill(1, weight);
       if (std::abs(Id) == 2)
         status1ShortLived->Fill(2, weight);
       if (std::abs(Id) == 3)
         status1ShortLived->Fill(3, weight);
       if (std::abs(Id) == 4)
         status1ShortLived->Fill(4, weight);
       if (std::abs(Id) == 5)
         status1ShortLived->Fill(5, weight);
       if (std::abs(Id) == 6)
         status1ShortLived->Fill(6, weight);
       if (Id == 21)
         status1ShortLived->Fill(7, weight);
       if (std::abs(Id) == 15)
         status1ShortLived->Fill(8, weight);
       if (Id == 23)
         status1ShortLived->Fill(9, weight);
       if (std::abs(Id) == 24)
         status1ShortLived->Fill(10, weight);
       if (std::abs(Id) == 7 || std::abs(Id) == 8 || std::abs(Id) == 17 || (std::abs(Id) >= 25 && std::abs(Id) <= 99))
         status1ShortLived->Fill(11, weight);
       etotal += ptcl->momentum().e();
       pxtotal += ptcl->momentum().px();
       pytotal += ptcl->momentum().py();
       pztotal += ptcl->momentum().pz();
     }
 
     if (abs(Id) < 6 || abs(Id) == 22) {
       ++partonNum;
       partonpT->Fill(Log_p, weight);
     }
 
     bool indentified = false;
     for (unsigned int i = 0; i < particles.size(); i++) {
       if (particles.at(i).Fill(ptcl, weight)) {
         indentified = true;
         break;
       }
     }
     if (!indentified) {
       ++otherPtclNum;
       otherPtclMomentum->Fill(Log_p, weight);
     }
   }  //event particles
 
   // set a default sqrt(s) and then check in the event
   double ecms = 13000.;
   if (myGenEvent->valid_beam_particles()) {
     ecms = myGenEvent->beam_particles().first->momentum().e() + myGenEvent->beam_particles().second->momentum().e();
   }
   log10DeltaEcms->Fill(log10(fabs(etotal - ecms)), weight);
   DeltaEcms->Fill(etotal - ecms, weight);
   DeltaPx->Fill(pxtotal, weight);
   DeltaPy->Fill(pytotal, weight);
   DeltaPz->Fill(pztotal, weight);
 
   stablePtclNumber->Fill(log10(stablePtclNum + 0.1), weight);
   stableChaNumber->Fill(log10(stableChaNum + 0.1), weight);
   otherPtclNumber->Fill(log10(otherPtclNum + 0.1), weight);
   unknownPDTNumber->Fill(log10(unknownPDTNum + 0.1), weight);
   //
   partonNumber->Fill(partonNum, weight);
   for (unsigned int i = 0; i < particles.size(); i++) {
     particles.at(i).FillCount(weight);
   };
 
 }  //analyze

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

overridevirtual

Setting the DQM top directories

Booking the ME's multiplicity

other

Implements DQMEDAnalyzer.

Definition at line 33 of file BasicHepMCValidation.cc.

References Bjorken_x, DQMHelper::book1dHisto(), DeltaEcms, DeltaPx, DeltaPy, DeltaPz, genPtclNumber, genPtclStatus, genVrtxNumber, log10DeltaEcms, logPdfMax, logPdfMin, logPdfNbin, nEvt, otherPtclMomentum, otherPtclNumber, outVrtxPtclNumber, outVrtxStablePtclNumber, particles, parton1Id, parton2Id, partonNumber, partonpT, pdf_bbbar, pdf_ccbar, pdf_d, pdf_dbar, pdf_g, pdf_ssbar, pdf_u, pdf_ubar, scalePDF, dqm::impl::MonitorElement::setBinLabel(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), stableChaNumber, stablePtclCharge, stablePtclEta, stablePtclNumber, stablePtclp, stablePtclPhi, stablePtclpT, status1ShortLived, unknownPDTNumber, vrtxRadius, and vrtxZ.

                                                                                                    {
   DQMHelper dqm(&i);
   i.setCurrentFolder("Generator/Particles");
 
   // Number of analyzed events
   nEvt = dqm.book1dHisto("nEvt", "n analyzed Events", 1, 0., 1.);
 
   // quarks
   particles.push_back(ParticleMonitor("u", 1, i));
   particles.push_back(ParticleMonitor("ubar", -1, i));
   particles.push_back(ParticleMonitor("d", 2, i));
   particles.push_back(ParticleMonitor("dbar", -2, i));
   particles.push_back(ParticleMonitor("s", 3, i));
   particles.push_back(ParticleMonitor("sbar", -3, i));
   particles.push_back(ParticleMonitor("c", 4, i));
   particles.push_back(ParticleMonitor("cbar", -4, i));
   particles.push_back(ParticleMonitor("b", 5, i));
   particles.push_back(ParticleMonitor("bbar", -5, i));
   particles.push_back(ParticleMonitor("t", 6, i));
   particles.push_back(ParticleMonitor("tbar", -6, i));
 
   //leptons
   particles.push_back(ParticleMonitor("eminus", 11, i));
   particles.push_back(ParticleMonitor("eplus", -11, i));
   particles.push_back(ParticleMonitor("nue", 12, i));
   particles.push_back(ParticleMonitor("nuebar", -12, i));
   particles.push_back(ParticleMonitor("muminus", 13, i));
   particles.push_back(ParticleMonitor("muplus", -13, i));
   particles.push_back(ParticleMonitor("numu", 14, i));
   particles.push_back(ParticleMonitor("numubar", -14, i));
   particles.push_back(ParticleMonitor("tauminus", 15, i));
   particles.push_back(ParticleMonitor("tauplus", -15, i));
   particles.push_back(ParticleMonitor("nutau", 16, i));
   particles.push_back(ParticleMonitor("nutaubar", -16, i));
 
   //bosons
   particles.push_back(ParticleMonitor("Wplus", 24, i));
   particles.push_back(ParticleMonitor("Wminus", -24, i));
   particles.push_back(ParticleMonitor("Z", 23, i));
   particles.push_back(ParticleMonitor("gamma", 22, i));
   particles.push_back(ParticleMonitor("gluon", 21, i));
 
   //mesons
   particles.push_back(ParticleMonitor("piplus", 211, i, true));    //log
   particles.push_back(ParticleMonitor("piminus", -211, i, true));  //log
   particles.push_back(ParticleMonitor("pizero", 111, i, true));    //log
   particles.push_back(ParticleMonitor("Kplus", 321, i));
   particles.push_back(ParticleMonitor("Kminus", -321, i));
   particles.push_back(ParticleMonitor("Klzero", 130, i));
   particles.push_back(ParticleMonitor("Kszero", 310, i));
 
   //baryons
   particles.push_back(ParticleMonitor("p", 2212, i, true));      //log
   particles.push_back(ParticleMonitor("pbar", -2212, i, true));  //log
   particles.push_back(ParticleMonitor("n", 2112, i, true));      //log
   particles.push_back(ParticleMonitor("nbar", -2112, i, true));  //log
   particles.push_back(ParticleMonitor("lambda0", 3122, i));
   particles.push_back(ParticleMonitor("lambda0bar", -3122, i));
 
   //D mesons
   particles.push_back(ParticleMonitor("Dplus", 411, i));
   particles.push_back(ParticleMonitor("Dminus", -411, i));
   particles.push_back(ParticleMonitor("Dzero", 421, i));
   particles.push_back(ParticleMonitor("Dzerobar", -421, i));
 
   //B mesons
   particles.push_back(ParticleMonitor("Bplus", 521, i));
   particles.push_back(ParticleMonitor("Bminus", -521, i));
   particles.push_back(ParticleMonitor("Bzero", 511, i));
   particles.push_back(ParticleMonitor("Bzerobar", -511, i));
   particles.push_back(ParticleMonitor("Bszero", 531, i));
   particles.push_back(ParticleMonitor("Bszerobar", -531, i));
 
   //
   otherPtclNumber = dqm.book1dHisto(
       "otherPtclNumber", "Log10(No. other ptcls)", 60, -1, 5, "log_{10}(No. other ptcls)", "Number of Events");  //Log
   otherPtclMomentum = dqm.book1dHisto("otherPtclMomentum",
                                       "Log10(p) other ptcls",
                                       60,
                                       -2,
                                       4,
                                       "log10(P^{other ptcls}) (log_{10}(GeV))",
                                       "Number of Events");
 
   genPtclNumber = dqm.book1dHisto(
       "genPtclNumber", "Log10(No. all particles)", 60, -1, 5, "log10(No. all particles)", "Number of Events");  //Log
   genVrtxNumber = dqm.book1dHisto(
       "genVrtxNumber", "Log10(No. all vertexs)", 60, -1, 5, "log10(No. all vertexs)", "Number of Events");  //Log
   //
   stablePtclNumber = dqm.book1dHisto("stablePtclNumber",
                                      "Log10(No. stable particles)",
                                      50,
                                      0,
                                      5,
                                      "log10(No. stable particles)",
                                      "Number of Events");  //Log
   stablePtclPhi = dqm.book1dHisto(
       "stablePtclPhi", "stable Ptcl Phi", 360, -180, 180, "#phi^{stable Ptcl} (rad)", "Number of Events");
   stablePtclEta = dqm.book1dHisto(
       "stablePtclEta", "stable Ptcl Eta (pseudo rapidity)", 220, -11, 11, "#eta^{stable Ptcl}", "Number of Events");
   stablePtclCharge =
       dqm.book1dHisto("stablePtclCharge", "stablePtclCharge", 5, -2, 2, "Charge^{stable ptcls}", "Number of Events");
   stableChaNumber = dqm.book1dHisto("stableChaNumber",
                                     "Log10(No. stable charged particles)",
                                     50,
                                     0,
                                     5,
                                     "log_{10}(No. stable charged particles)",
                                     "Number of Events");  //Log
   stablePtclp = dqm.book1dHisto("stablePtclp",
                                 "Log10(p) stable ptcl p",
                                 80,
                                 -4,
                                 4,
                                 "log_{10}(P^{stable ptcl}) (log_{10}(GeV))",
                                 "Number of Events");  //Log
   stablePtclpT = dqm.book1dHisto("stablePtclpT",
                                  "Log10(pT) stable ptcl pT",
                                  80,
                                  -4,
                                  4,
                                  "log_{10}(P_{t}^{stable ptcl}) (log_{10}(GeV))",
                                  "Number of Events");  //Log
   partonNumber =
       dqm.book1dHisto("partonNumber", "number of partons", 100, 0, 100, "number of partons", "Number of Events");
   partonpT =
       dqm.book1dHisto("partonpT", "Log10(pT) parton pT", 80, -4, 4, "Log10(P_{t}^{parton})", "Number of Events");  //Log
   outVrtxStablePtclNumber = dqm.book1dHisto("outVrtxStablePtclNumber",
                                             "No. outgoing stable ptcls from vrtx",
                                             10,
                                             0,
                                             10,
                                             "No. outgoing stable ptcls from vrtx",
                                             "Number of Events");
   //
   outVrtxPtclNumber = dqm.book1dHisto("outVrtxPtclNumber",
                                       "No. outgoing ptcls from vrtx",
                                       30,
                                       0,
                                       30,
                                       "No. outgoing ptcls from vrtx",
                                       "Number of Events");
   vrtxZ = dqm.book1dHisto("VrtxZ", "VrtxZ", 50, -250, 250, "Z_{Vtx}", "Number of Events");
   vrtxRadius = dqm.book1dHisto("vrtxRadius", "vrtxRadius", 50, 0, 50, "R_{vtx}", "Number of Events");
   //
   unknownPDTNumber = dqm.book1dHisto("unknownPDTNumber",
                                      "Log10(No. unknown ptcls PDT)",
                                      60,
                                      -1,
                                      5,
                                      "log_{10}(No. unknown ptcls PDT)",
                                      "Number of Events");  //Log
   genPtclStatus = dqm.book1dHisto("genPtclStatus", "Status of genParticle", 200, 0, 200., "", "Number of Events");
   //
   Bjorken_x = dqm.book1dHisto("Bjorken_x", "Bjorken_x", 1000, 0.0, 1.0, "Bjorken_{x}", "Number of Events");
   pdf_u = dqm.book1dHisto(
       "pdf_u", "Log10(PDF(u,x,Q))", logPdfNbin, logPdfMin, logPdfMax, "log_{10}(x*f(x))", "Number of Events");  //Log
   pdf_ubar = dqm.book1dHisto("pdf_ubar",
                              "Log10(PDF(ubar,x,Q))",
                              logPdfNbin,
                              logPdfMin,
                              logPdfMax,
                              "log_{10}(x*f(x))",
                              "Number of Events");  //Log
   pdf_d = dqm.book1dHisto(
       "pdf_d", "Log10(PDF(d,x,Q))", logPdfNbin, logPdfMin, logPdfMax, "log_{10}(x*f(x))", "Number of Events");  //Log
   pdf_dbar = dqm.book1dHisto("pdf_dbar",
                              "Log10(PDF(dbar,x,Q))",
                              logPdfNbin,
                              logPdfMin,
                              logPdfMax,
                              "log_{10}(x*f(x))",
                              "Number of Events");  //Log
   pdf_ssbar = dqm.book1dHisto("pdf_ssbar",
                               "Log10(PDF(ssbar,x,Q))",
                               logPdfNbin,
                               logPdfMin,
                               logPdfMax,
                               "log_{10}(x*f(x))",
                               "Number of Events");  //Log
   pdf_ccbar = dqm.book1dHisto("pdf_ccbar",
                               "Log10(PDF(ccbar,x,Q))",
                               logPdfNbin,
                               logPdfMin,
                               logPdfMax,
                               "log_{10}(x*f(x))",
                               "Number of Events");  //Log
   pdf_bbbar = dqm.book1dHisto("pdf_bbbar",
                               "Log10(PDF(bbbar,x,Q))",
                               logPdfNbin,
                               logPdfMin,
                               logPdfMax,
                               "log_{10}(x*f(x))",
                               "Number of Events");  //Log
   pdf_g = dqm.book1dHisto(
       "pdf_g", "Log10(PDF(g,x,Q))", logPdfNbin, logPdfMin, logPdfMax, "log_{10}(x*f(x))", "Number of Events");  //Log
   scalePDF = dqm.book1dHisto("scalePDF",
                              "Log10(Q-scale(GeV))",
                              logQScaleNbin,
                              logQScaleMin,
                              logQScaleMax,
                              "log_{10}(Q-scale(GeV))",
                              "Number of Events");
   parton1Id = dqm.book1dHisto("parton1Id", "ID of parton 1", 45, -14.5, 30.5, "ID", "Number of Events");
   parton2Id = dqm.book1dHisto("parton2Id", "ID of parton 2", 45, -14.5, 30.5, "ID", "Number of Events");
   //
   status1ShortLived = dqm.book1dHisto("status1ShortLived", "Status 1 short lived", 11, 0, 11, "", "Number of Events");
   status1ShortLived->setBinLabel(1, "d/dbar");
   status1ShortLived->setBinLabel(2, "u/ubar");
   status1ShortLived->setBinLabel(3, "s/sbar");
   status1ShortLived->setBinLabel(4, "c/cbar");
   status1ShortLived->setBinLabel(5, "b/bbar");
   status1ShortLived->setBinLabel(6, "t/tbar");
   status1ShortLived->setBinLabel(7, "g");
   status1ShortLived->setBinLabel(8, "tau-/tau+");
   status1ShortLived->setBinLabel(9, "Z0");
   status1ShortLived->setBinLabel(10, "W-/W+");
   status1ShortLived->setBinLabel(11, "PDG = 7,8,17,25-99");
 
   log10DeltaEcms = dqm.book1dHisto("DeltaEcms1log10",
                                    "log_{10} of deviation from nominal Ecms",
                                    200,
                                    -1.,
                                    5.,
                                    "log_{10}(#DeltaE) (log_{10}(GeV))",
                                    "Number of Events");
   DeltaEcms =
       dqm.book1dHisto("DeltaEcms1", "deviation from nominal Ecms", 200, -1., 1., "#DeltaE (GeV)", "Number of Events");
   DeltaPx =
       dqm.book1dHisto("DeltaPx1", "deviation from nominal Px", 200, -1., 1., "#DeltaP_{x} (GeV)", "Number of Events");
   DeltaPy =
       dqm.book1dHisto("DeltaPy1", "deviation from nominal Py", 200, -1., 1., "#DeltaP_{y} (GeV)", "Number of Events");
   DeltaPz =
       dqm.book1dHisto("DeltaPz1", "deviation from nominal Pz", 200, -1., 1., "#DeltaP_{z} (GeV)", "Number of Events");
   return;
 }