#include <V0Monitor.h>

Inheritance diagram for V0Monitor:

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

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

Public Member Functions
	V0Monitor (const edm::ParameterSet &)

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

Protected Member Functions
void	analyze (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

MonitorElement *	bookHisto1D (DQMStore::IBooker &ibooker, std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning binning)

MonitorElement *	bookHisto2D (DQMStore::IBooker &ibooker, std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning xbinning, MEbinning ybinning)

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

MonitorElement *	bookProfile (DQMStore::IBooker &ibooker, std::string name, std::string title, std::string xaxis, std::string yaxis, MEbinning xbinning, MEbinning ybinning)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Member Functions
void	getHistoPSet (edm::ParameterSet pset, MEbinning &mebinning)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	bsToken_

MEbinning	chi2oNDF_binning_

MEbinning	eta_binning_

std::string	folderName_

const bool	forceSCAL_

GenericTriggerEventFlag *	genTriggerEventFlag_

MEbinning	ls_binning_

MEbinning	lumi_binning_

edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_

MEbinning	Lxy_binning_

MEbinning	mass_binning_

edm::EDGetTokenT< OnlineLuminosityRecord >	metaDataToken_

MonitorElement *	n_vs_BX_

MonitorElement *	n_vs_LS_

MonitorElement *	n_vs_lumi_

MonitorElement *	n_vs_PU_

MEbinning	pt_binning_

MEbinning	pu_binning_

int	pvNDOF_

edm::EDGetTokenT< reco::VertexCollection >	pvToken_

MonitorElement *	v0_chi2oNDF_

MonitorElement *	v0_deltaMass_

MonitorElement *	v0_deltaMass_vs_BX_

MonitorElement *	v0_deltaMass_vs_eta_

MonitorElement *	v0_deltaMass_vs_lumi_

MonitorElement *	v0_deltaMass_vs_pt_

MonitorElement *	v0_deltaMass_vs_PU_

MonitorElement *	v0_eta_

MonitorElement *	v0_Lxy_

MonitorElement *	v0_Lxy_vs_BX_

MonitorElement *	v0_Lxy_vs_deltaMass_

MonitorElement *	v0_Lxy_vs_eta_

MonitorElement *	v0_Lxy_vs_lumi_

MonitorElement *	v0_Lxy_vs_pt_

MonitorElement *	v0_Lxy_vs_PU_

MonitorElement *	v0_Lxy_wrtBS_

MonitorElement *	v0_mass_

MonitorElement *	v0_mass_vs_BX_

MonitorElement *	v0_mass_vs_eta_

MonitorElement *	v0_mass_vs_lumi_

MonitorElement *	v0_mass_vs_p_

MonitorElement *	v0_mass_vs_pt_

MonitorElement *	v0_mass_vs_PU_

MonitorElement *	v0_N_

MonitorElement *	v0_N_vs_BX_

MonitorElement *	v0_N_vs_LS_

MonitorElement *	v0_N_vs_lumi_

MonitorElement *	v0_N_vs_PU_

MonitorElement *	v0_phi_

MonitorElement *	v0_pt_

edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	v0Token_

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

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

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

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

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 40 of file V0Monitor.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore V0Monitor::DQMStore

Definition at line 42 of file V0Monitor.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement V0Monitor::MonitorElement

Definition at line 43 of file V0Monitor.h.

Constructor & Destructor Documentation

◆ V0Monitor()

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

Definition at line 15 of file V0Monitor.cc.

References chi2oNDF_binning_, eta_binning_, getHistoPSet(), edm::ParameterSet::getParameter(), V0Monitor_cff::histoPSet, ls_binning_, lumi_binning_, Lxy_binning_, mass_binning_, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, pt_binning_, pu_binning_, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, and v0_pt_.

     : folderName_(iConfig.getParameter<std::string>("FolderName")),
       v0Token_(consumes<reco::VertexCompositeCandidateCollection>(iConfig.getParameter<edm::InputTag>("v0"))),
       bsToken_(consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot"))),
       pvToken_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertex"))),
       lumiscalersToken_(consumes<LumiScalersCollection>(iConfig.getParameter<edm::InputTag>("lumiScalers"))),
       metaDataToken_(consumes<OnlineLuminosityRecord>(iConfig.getParameter<edm::InputTag>("metadata"))),
       forceSCAL_(iConfig.getParameter<bool>("forceSCAL")),
       pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
       genTriggerEventFlag_(new GenericTriggerEventFlag(
           iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"), consumesCollector(), *this)) {
   v0_N_ = nullptr;
   v0_mass_ = nullptr;
   v0_pt_ = nullptr;
   v0_eta_ = nullptr;
   v0_phi_ = nullptr;
   v0_Lxy_ = nullptr;
   v0_Lxy_wrtBS_ = nullptr;
   v0_chi2oNDF_ = nullptr;
   v0_mass_vs_p_ = nullptr;
   v0_mass_vs_pt_ = nullptr;
   v0_mass_vs_eta_ = nullptr;
   v0_deltaMass_ = nullptr;
   v0_deltaMass_vs_pt_ = nullptr;
   v0_deltaMass_vs_eta_ = nullptr;
 
   v0_Lxy_vs_deltaMass_ = nullptr;
   v0_Lxy_vs_pt_ = nullptr;
   v0_Lxy_vs_eta_ = nullptr;
 
   n_vs_BX_ = nullptr;
   v0_N_vs_BX_ = nullptr;
   v0_mass_vs_BX_ = nullptr;
   v0_Lxy_vs_BX_ = nullptr;
   v0_deltaMass_vs_BX_ = nullptr;
 
   n_vs_lumi_ = nullptr;
   v0_N_vs_lumi_ = nullptr;
   v0_mass_vs_lumi_ = nullptr;
   v0_Lxy_vs_lumi_ = nullptr;
   v0_deltaMass_vs_lumi_ = nullptr;
 
   n_vs_PU_ = nullptr;
   v0_N_vs_PU_ = nullptr;
   v0_mass_vs_PU_ = nullptr;
   v0_Lxy_vs_PU_ = nullptr;
   v0_deltaMass_vs_PU_ = nullptr;
 
   n_vs_LS_ = nullptr;
   v0_N_vs_LS_ = nullptr;
 
   edm::ParameterSet histoPSet = iConfig.getParameter<edm::ParameterSet>("histoPSet");
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("massPSet"), mass_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("ptPSet"), pt_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("etaPSet"), eta_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("LxyPSet"), Lxy_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("chi2oNDFPSet"), chi2oNDF_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("lumiPSet"), lumi_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("puPSet"), pu_binning_);
   getHistoPSet(histoPSet.getParameter<edm::ParameterSet>("lsPSet"), ls_binning_);
 }

◆ ~V0Monitor()

V0Monitor::~V0Monitor ( )

override

Definition at line 77 of file V0Monitor.cc.

References genTriggerEventFlag_.

                       {
   if (genTriggerEventFlag_)
     delete genTriggerEventFlag_;
 }

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 228 of file V0Monitor.cc.

References GenericTriggerEventFlag::accept(), cms::cuda::bs, bsToken_, simKBmtfDigis_cfi::bx, dumpMFGeometry_cfg::delta, PVValHelper::eta, dqm::impl::MonitorElement::Fill(), forceSCAL_, genTriggerEventFlag_, iEvent, OnlineLuminosityRecord::instLumi(), edm::HandleBase::isValid(), V0Monitor_cfi::lumiScalers, lumiscalersToken_, EgHLTOffHistBins_cfi::mass, metaDataToken_, dqmiodumpmetadata::n, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, nPV, GenericTriggerEventFlag::on(), or, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp(), phi, edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, pvNDOF_, pvToken_, findQualityFiles::v, V0Monitor_cff::v0, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, v0_pt_, and v0Token_.

                                                                            {
   // Filter out events if Trigger Filtering is requested
   if (genTriggerEventFlag_->on() && !genTriggerEventFlag_->accept(iEvent, iSetup))
     return;
 
   //  int ls = iEvent.id().luminosityBlock();
 
   size_t bx = iEvent.bunchCrossing();
   n_vs_BX_->Fill(bx);
 
   float lumi = -1.;
   if (forceSCAL_) {
     edm::Handle<LumiScalersCollection> lumiScalers = iEvent.getHandle(lumiscalersToken_);
     if (lumiScalers.isValid() && !lumiScalers->empty()) {
       LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
       lumi = scalit->instantLumi();
     }
   } else {
     edm::Handle<OnlineLuminosityRecord> metaData = iEvent.getHandle(metaDataToken_);
     if (metaData.isValid())
       lumi = metaData->instLumi();
   }
 
   n_vs_lumi_->Fill(lumi);
 
   edm::Handle<reco::BeamSpot> beamspotHandle = iEvent.getHandle(bsToken_);
   reco::BeamSpot const* bs = nullptr;
   if (beamspotHandle.isValid())
     bs = &(*beamspotHandle);
 
   edm::Handle<reco::VertexCollection> pvHandle = iEvent.getHandle(pvToken_);
   reco::Vertex const* pv = nullptr;
   size_t nPV = 0;
   if (pvHandle.isValid()) {
     pv = &pvHandle->front();
     //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
     if (pv->isFake() ||
         pv->tracksSize() == 0
         // definition of goodOfflinePrimaryVertex
         || pv->ndof() < pvNDOF_ || pv->z() > 24.)
       pv = nullptr;
 
     for (const auto& v : *pvHandle) {
       if (v.isFake())
         continue;
       if (v.ndof() < pvNDOF_)
         continue;
       if (v.z() > 24.)
         continue;
       ++nPV;
     }
   }
   n_vs_PU_->Fill(nPV);
 
   float nLS = static_cast<float>(iEvent.id().luminosityBlock());
   n_vs_LS_->Fill(nLS);
 
   edm::Handle<reco::VertexCompositeCandidateCollection> v0Handle = iEvent.getHandle(v0Token_);
   int n = (v0Handle.isValid() ? v0Handle->size() : -1);
   v0_N_->Fill(n);
   v0_N_vs_BX_->Fill(bx, n);
   v0_N_vs_lumi_->Fill(lumi, n);
   v0_N_vs_PU_->Fill(nPV, n);
   v0_N_vs_LS_->Fill(nLS, n);
 
   if (!v0Handle.isValid() or n == 0)
     return;
 
   reco::VertexCompositeCandidateCollection v0s = *v0Handle.product();
   for (const auto& v0 : v0s) {
     float mass = v0.mass();
     float pt = v0.pt();
     float p = v0.p();
     float eta = v0.eta();
     float phi = v0.phi();
     int pdgID = v0.pdgId();
     float chi2oNDF = v0.vertexNormalizedChi2();
     GlobalPoint displacementFromPV =
         (pv == nullptr ? GlobalPoint(-9., -9., 0) : GlobalPoint((pv->x() - v0.vx()), (pv->y() - v0.vy()), 0.));
     GlobalPoint displacementFromBS =
         (bs == nullptr
              ? GlobalPoint(-9., -9., 0.)
              : GlobalPoint(-1 * ((bs->position().x() - v0.vx()) + (v0.vz() - bs->position().z()) * bs->dxdz()),
                            -1 * ((bs->position().y() - v0.vy()) + (v0.vz() - bs->position().z()) * bs->dydz()),
                            0));
     float lxy = (pv == nullptr ? -9. : displacementFromPV.perp());
     float lxyWRTbs = (bs == nullptr ? -9. : displacementFromBS.perp());
 
     v0_mass_->Fill(mass);
     v0_pt_->Fill(pt);
     v0_eta_->Fill(eta);
     v0_phi_->Fill(phi);
     v0_Lxy_->Fill(lxy);
     v0_Lxy_wrtBS_->Fill(lxyWRTbs);
     v0_chi2oNDF_->Fill(chi2oNDF);
 
     v0_mass_vs_p_->Fill(p, mass);
     v0_mass_vs_pt_->Fill(pt, mass);
     v0_mass_vs_eta_->Fill(eta, mass);
     v0_mass_vs_BX_->Fill(bx, mass);
     v0_mass_vs_lumi_->Fill(lumi, mass);
     v0_mass_vs_PU_->Fill(nPV, mass);
 
     v0_Lxy_vs_BX_->Fill(bx, lxy);
     v0_Lxy_vs_lumi_->Fill(lumi, lxy);
     v0_Lxy_vs_PU_->Fill(nPV, lxy);
 
     float PDGmass = -9999.;
     switch (pdgID) {
       case 130:              // K_s
       case 310:              // K_L
         PDGmass = 0.497614;  // GeV
         break;
       case 3122:             // Lambda
       case -3122:            // Lambda
         PDGmass = 1.115683;  // GeV
         break;
       case 4122:   // Lambda_c
       case -4122:  // Lambda_c
       case 5122:   // Lambda_b
       case -5122:  // Lambda_b
       default:
         break;
     }
     float delta = (PDGmass > 0. ? (mass - PDGmass) / PDGmass : -9.);
     v0_deltaMass_->Fill(delta);
     v0_deltaMass_vs_pt_->Fill(pt, delta);
     v0_deltaMass_vs_eta_->Fill(eta, delta);
     v0_deltaMass_vs_BX_->Fill(bx, delta);
     v0_deltaMass_vs_lumi_->Fill(lumi, delta);
     v0_deltaMass_vs_PU_->Fill(nPV, delta);
 
     v0_Lxy_vs_deltaMass_->Fill(delta, lxy);
     v0_Lxy_vs_pt_->Fill(pt, lxy);
     v0_Lxy_vs_eta_->Fill(eta, lxy);
   }
 }

◆ bookHisto1D()

V0Monitor::MonitorElement * V0Monitor::bookHisto1D	(	DQMStore::IBooker &	ibooker,
		std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	binning
	)

protected

Definition at line 88 of file V0Monitor.cc.

References pileupCalc::binning, dqm::implementation::IBooker::book1D(), Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, and TimingClient_cfi::yaxis.

Referenced by bookHistograms().

                                                                      {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return ibooker.book1D(name, title_w_axes, binning.nbins, binning.xmin, binning.xmax);
 }

◆ bookHisto2D()

V0Monitor::MonitorElement * V0Monitor::bookHisto2D	(	DQMStore::IBooker &	ibooker,
		std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	xbinning,
		MEbinning	ybinning
	)

protected

Definition at line 97 of file V0Monitor.cc.

References dqm::implementation::IBooker::book2D(), Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, and TimingClient_cfi::yaxis.

                                                                       {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return ibooker.book2D(
       name, title_w_axes, xbinning.nbins, xbinning.xmin, xbinning.xmax, ybinning.nbins, ybinning.xmin, ybinning.xmax);
 }

◆ bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 120 of file V0Monitor.cc.

References bookHisto1D(), bookProfile(), chi2oNDF_binning_, eta_binning_, folderName_, genTriggerEventFlag_, dqm::legacy::MonitorElement::getTH1(), GenericTriggerEventFlag::initRun(), ls_binning_, lumi_binning_, Lxy_binning_, mass_binning_, n_vs_BX_, n_vs_LS_, n_vs_lumi_, n_vs_PU_, GenericTriggerEventFlag::on(), pt_binning_, pu_binning_, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, v0_chi2oNDF_, v0_deltaMass_, v0_deltaMass_vs_BX_, v0_deltaMass_vs_eta_, v0_deltaMass_vs_lumi_, v0_deltaMass_vs_pt_, v0_deltaMass_vs_PU_, v0_eta_, v0_Lxy_, v0_Lxy_vs_BX_, v0_Lxy_vs_deltaMass_, v0_Lxy_vs_eta_, v0_Lxy_vs_lumi_, v0_Lxy_vs_pt_, v0_Lxy_vs_PU_, v0_Lxy_wrtBS_, v0_mass_, v0_mass_vs_BX_, v0_mass_vs_eta_, v0_mass_vs_lumi_, v0_mass_vs_p_, v0_mass_vs_pt_, v0_mass_vs_PU_, v0_N_, v0_N_vs_BX_, v0_N_vs_LS_, v0_N_vs_lumi_, v0_N_vs_PU_, v0_phi_, and v0_pt_.

                                                                                                         {
   std::string histname, histtitle;
 
   std::string currentFolder = folderName_;
   ibooker.setCurrentFolder(currentFolder);
 
   MEbinning N_binning;
   N_binning.nbins = 15;
   N_binning.xmin = -0.5;
   N_binning.xmax = 14.5;
   v0_N_ = bookHisto1D(ibooker, "v0_N", "# v0", "# v0", "events", N_binning);
   v0_mass_ = bookHisto1D(ibooker, "v0_mass", "mass", "mass [GeV]", "events", mass_binning_);
   v0_pt_ = bookHisto1D(ibooker, "v0_pt", "pt", "p_{T} [GeV]", "events", pt_binning_);
   v0_eta_ = bookHisto1D(ibooker, "v0_eta", "eta", "#eta", "events", eta_binning_);
   MEbinning phi_binning;
   phi_binning.nbins = 34;
   phi_binning.xmin = -3.2;
   phi_binning.xmax = 3.2;
   v0_phi_ = bookHisto1D(ibooker, "v0_phi", "phi", "#phi [rad]", "events", phi_binning);
   v0_Lxy_ = bookHisto1D(ibooker, "v0_Lxy", "Lxy", "L_{xy} w.r.t. PV [cm]", "events", Lxy_binning_);
   v0_Lxy_wrtBS_ = bookHisto1D(ibooker, "v0_Lxy_wrtBS", "Lxy", "L_{xy} w.r.t. BS [cm]", "events", Lxy_binning_);
   v0_chi2oNDF_ =
       bookHisto1D(ibooker, "v0_chi2oNDF", "chi2oNDF", "vertex normalized #chi^{2}", "events", chi2oNDF_binning_);
 
   v0_mass_vs_p_ =
       bookProfile(ibooker, "v0_mass_vs_p", "mass vs p", "p [GeV]", "mass [GeV]", pt_binning_, mass_binning_);
   v0_mass_vs_pt_ =
       bookProfile(ibooker, "v0_mass_vs_pt", "mass vs pt", "p_{T} [GeV]", "mass [GeV]", pt_binning_, mass_binning_);
   v0_mass_vs_eta_ =
       bookProfile(ibooker, "v0_mass_vs_eta", "mass vs eta", "#eta", "mass [GeV]", eta_binning_, mass_binning_);
 
   MEbinning delta_binning;
   delta_binning.nbins = 150;
   delta_binning.xmin = -0.15;
   delta_binning.xmax = 0.15;
   v0_deltaMass_ = bookHisto1D(ibooker, "v0_deltaMass", "deltaMass", "m-m_{PDG}/m_{DPG}", "events", delta_binning);
   v0_deltaMass_vs_pt_ = bookProfile(
       ibooker, "v0_deltaMass_vs_pt", "deltaMass vs pt", "p_{T} [GeV]", "m-m_{PDG}/m_{DPG}", pt_binning_, delta_binning);
   v0_deltaMass_vs_eta_ = bookProfile(
       ibooker, "v0_deltaMass_vs_eta", "deltaMass vs eta", "#eta", "m-m_{PDG}/m_{DPG}", eta_binning_, delta_binning);
 
   v0_Lxy_vs_deltaMass_ = bookProfile(ibooker,
                                      "v0_Lxy_vs_deltaMass",
                                      "L_{xy} vs deltaMass",
                                      "m-m_{PDG}/m_{DPG}",
                                      "L_{xy} [cm]",
                                      delta_binning,
                                      Lxy_binning_);
   v0_Lxy_vs_pt_ =
       bookProfile(ibooker, "v0_Lxy_vs_pt", "L_{xy} vs p_{T}", "p_{T} [GeV]", "L_{xy} [cm]", pt_binning_, Lxy_binning_);
   v0_Lxy_vs_eta_ =
       bookProfile(ibooker, "v0_Lxy_vs_eta", "L_{xy} vs #eta", "#eta", "L_{xy} [cm]", eta_binning_, Lxy_binning_);
 
   MEbinning bx_binning;
   bx_binning.nbins = 3564;
   bx_binning.xmin = 0.5;
   bx_binning.xmax = 3564.5;
   n_vs_BX_ = bookHisto1D(ibooker, "n_vs_BX", "# events vs BX", "BX", "# events", bx_binning);
   v0_N_vs_BX_ = bookProfile(ibooker, "v0_N_vs_BX", "# v0 vs BX", "BX", "# v0", bx_binning, N_binning);
   v0_mass_vs_BX_ = bookProfile(ibooker, "v0_mass_vs_BX", "mass vs BX", "BX", "mass [GeV]", bx_binning, mass_binning_);
   v0_Lxy_vs_BX_ = bookProfile(ibooker, "v0_Lxy_vs_BX", "L_{xy} vs BX", "BX", "L_{xy} [cm]", bx_binning, Lxy_binning_);
   v0_deltaMass_vs_BX_ = bookProfile(
       ibooker, "v0_deltaMass_vs_BX", "deltaMass vs BX", "BX", "m-m_{PDG}/m_{DPG}", bx_binning, delta_binning);
 
   n_vs_lumi_ = bookHisto1D(
       ibooker, "n_vs_lumi", "# events vs lumi", "inst. lumi x10^{30} [Hz cm^{-2}]", "# events", lumi_binning_);
   v0_N_vs_lumi_ = bookProfile(
       ibooker, "v0_N_vs_lumi", "# v0 vs lumi", "inst. lumi x10^{30} [Hz cm^{-2}]", "# v0", lumi_binning_, N_binning);
   v0_mass_vs_lumi_ = bookProfile(ibooker,
                                  "v0_mass_vs_lumi",
                                  "mass vs lumi",
                                  "inst. lumi x10^{30} [Hz cm^{-2}]",
                                  "mass [GeV]",
                                  lumi_binning_,
                                  mass_binning_);
   v0_Lxy_vs_lumi_ = bookProfile(ibooker,
                                 "v0_Lxy_vs_lumi",
                                 "L_{xy} vs lumi",
                                 "inst. lumi x10^{30} [Hz cm^{-2}]",
                                 "L_{xy} [cm]",
                                 lumi_binning_,
                                 Lxy_binning_);
   v0_deltaMass_vs_lumi_ = bookProfile(ibooker,
                                       "v0_deltaMass_vs_lumi",
                                       "deltaMass vs lumi",
                                       "inst. lumi x10^{30} [Hz cm^{-2}]",
                                       "m-m_{PDG}/m_{DPG}",
                                       lumi_binning_,
                                       delta_binning);
 
   n_vs_PU_ = bookHisto1D(ibooker, "n_vs_PU", "# events vs PU", "# good PV", "# events", pu_binning_);
   v0_N_vs_PU_ = bookProfile(ibooker, "v0_N_vs_PU", "# v0 vs PU", "# good PV", "# v0", pu_binning_, N_binning);
   v0_mass_vs_PU_ =
       bookProfile(ibooker, "v0_mass_vs_PU", "mass vs PU", "# good PV", "mass [GeV]", pu_binning_, mass_binning_);
   v0_Lxy_vs_PU_ =
       bookProfile(ibooker, "v0_Lxy_vs_PU", "L_{xy} vs PU", "# good PV", "L_{xy} [cm]", pu_binning_, Lxy_binning_);
   v0_deltaMass_vs_PU_ = bookProfile(
       ibooker, "v0_deltaMass_vs_PU", "deltaMass vs PU", "# good PV", "m-m_{PDG}/m_{DPG}", pu_binning_, delta_binning);
 
   n_vs_LS_ = bookHisto1D(ibooker, "n_vs_LS", "# events vs LS", "LS", "# events", ls_binning_);
   v0_N_vs_LS_ = bookProfile(ibooker, "v0_N_vs_LS", "# v0 vs LS", "LS", "# v0", ls_binning_, N_binning);
   v0_N_vs_LS_->getTH1()->SetCanExtend(TH1::kAllAxes);
 
   // Initialize the GenericTriggerEventFlag
   if (genTriggerEventFlag_->on())
     genTriggerEventFlag_->initRun(iRun, iSetup);
 }

◆ bookProfile()

V0Monitor::MonitorElement * V0Monitor::bookProfile	(	DQMStore::IBooker &	ibooker,
		std::string	name,
		std::string	title,
		std::string	xaxis,
		std::string	yaxis,
		MEbinning	xbinning,
		MEbinning	ybinning
	)

protected

Definition at line 108 of file V0Monitor.cc.

References dqm::implementation::IBooker::bookProfile(), Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, and TimingClient_cfi::yaxis.

Referenced by bookHistograms().

                                                                       {
   std::string title_w_axes = title + ";" + xaxis + ";" + yaxis;
   return ibooker.bookProfile(
       name, title_w_axes, xbinning.nbins, xbinning.xmin, xbinning.xmax, ybinning.xmin, ybinning.xmax);
 }

◆ getHistoPSet()

void V0Monitor::getHistoPSet	(	edm::ParameterSet	pset,
		MEbinning &	mebinning
	)

private

Definition at line 82 of file V0Monitor.cc.

References muonDTDigis_cfi::pset.

Referenced by V0Monitor().

                                                                        {
   mebinning.nbins = pset.getParameter<int32_t>("nbins");
   mebinning.xmin = pset.getParameter<double>("xmin");
   mebinning.xmax = pset.getParameter<double>("xmax");
 }