#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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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
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
const edm::EDGetTokenT< reco::BeamSpot >	bsToken_

MEbinning	chi2oNDF_binning_

MEbinning	eta_binning_

const std::string	folderName_

const bool	forceSCAL_

GenericTriggerEventFlag *	genTriggerEventFlag_

MEbinning	ls_binning_

MEbinning	lumi_binning_

const edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_

MEbinning	Lxy_binning_

MEbinning	mass_binning_

const 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_

const int	pvNDOF_

const 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_

const edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	v0Token_

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 37 of file V0Monitor.h.

Member Typedef Documentation

◆ DQMStore

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

Definition at line 39 of file V0Monitor.h.

◆ MonitorElement

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

Definition at line 40 of file V0Monitor.h.

Constructor & Destructor Documentation

◆ V0Monitor()

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

Definition at line 92 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 154 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 305 of file V0Monitor.cc.

References GenericTriggerEventFlag::accept(), cms::cuda::bs, bsToken_, nano_mu_digi_cff::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 165 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 174 of file V0Monitor.cc.

References dqm::implementation::IBooker::book2D(), Skims_PA_cff::name, MEbinning::nbins, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, MEbinning::xmax, MEbinning::xmin, 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 197 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_, MEbinning::nbins, 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_, v0_pt_, MEbinning::xmax, and MEbinning::xmin.

                                                                                                         {
   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 185 of file V0Monitor.cc.

References dqm::implementation::IBooker::bookProfile(), Skims_PA_cff::name, MEbinning::nbins, AlCaHLTBitMon_QueryRunRegistry::string, runGCPTkAlMap::title, LaserClient_cfi::xaxis, MEbinning::xmax, MEbinning::xmin, 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);
 }

◆ fillDescriptions()

void V0Monitor::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 11 of file V0Monitor.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, GenericTriggerEventFlag::fillPSetDescription(), SiStripSourceConfigTier0_cff::genericTriggerEventPSet, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("FolderName", "Tracking/V0Monitoring");
   desc.add<edm::InputTag>("v0", edm::InputTag("generalV0Candidates:Kshort"));
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("primaryVertex", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("lumiScalers", edm::InputTag("scalersRawToDigi"));
   desc.add<bool>("forceSCAL", true);
   desc.add<edm::InputTag>("metadata", edm::InputTag("onlineMetaDataDigis"));
   desc.add<int>("pvNDOF", 4);
 
   {
     edm::ParameterSetDescription psd0;
     {
       edm::ParameterSetDescription psd1;
       psd1.add<int>("nbins", 3700);
       psd1.add<double>("xmin", 0.);
       psd1.add<double>("xmax", 14000.);
       psd0.add<edm::ParameterSetDescription>("lumiPSet", psd1);
     }
     {
       edm::ParameterSetDescription psd2;
       psd2.add<int>("nbins", 100);
       psd2.add<double>("xmin", 0.400);
       psd2.add<double>("xmax", 0.600);
       psd0.add<edm::ParameterSetDescription>("massPSet", psd2);
     }
     {
       edm::ParameterSetDescription psd3;
       psd3.add<int>("nbins", 100);
       psd3.add<double>("xmin", 0.);
       psd3.add<double>("xmax", 50.);
       psd0.add<edm::ParameterSetDescription>("ptPSet", psd3);
     }
     {
       edm::ParameterSetDescription psd4;
       psd4.add<int>("nbins", 60);
       psd4.add<double>("xmin", -3.);
       psd4.add<double>("xmax", 3.);
       psd0.add<edm::ParameterSetDescription>("etaPSet", psd4);
     }
     {
       edm::ParameterSetDescription psd5;
       psd5.add<int>("nbins", 350);
       psd5.add<double>("xmin", 0.);
       psd5.add<double>("xmax", 70.);
       psd0.add<edm::ParameterSetDescription>("LxyPSet", psd5);
     }
     {
       edm::ParameterSetDescription psd6;
       psd6.add<int>("nbins", 100);
       psd6.add<double>("xmin", 0.);
       psd6.add<double>("xmax", 30.);
       psd0.add<edm::ParameterSetDescription>("chi2oNDFPSet", psd6);
     }
     {
       edm::ParameterSetDescription psd7;
       psd7.add<int>("nbins", 100);
       psd7.add<double>("xmin", -0.5);
       psd7.add<double>("xmax", 99.5);
       psd0.add<edm::ParameterSetDescription>("puPSet", psd7);
     }
     {
       edm::ParameterSetDescription psd8;
       psd8.add<int>("nbins", 2000);
       psd8.add<double>("xmin", 0.);
       psd8.add<double>("xmax", 2000.);
       psd0.add<edm::ParameterSetDescription>("lsPSet", psd8);
     }
     desc.add<edm::ParameterSetDescription>("histoPSet", psd0);
   }
 
   {
     edm::ParameterSetDescription genericTriggerEventPSet;
     GenericTriggerEventFlag::fillPSetDescription(genericTriggerEventPSet);
     desc.add<edm::ParameterSetDescription>("genericTriggerEventPSet", genericTriggerEventPSet);
   }
 
   descriptions.addWithDefaultLabel(desc);
 }

◆ getHistoPSet()

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

private

Definition at line 159 of file V0Monitor.cc.

References MEbinning::nbins, muonDTDigis_cfi::pset, MEbinning::xmax, and MEbinning::xmin.

Referenced by V0Monitor().

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