#include <NoBPTXMonitor.h>

Inheritance diagram for NoBPTXMonitor:

Classes
struct	NoBPTXbinning

struct	NoBPTXME

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

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

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

static void	fillHistoLSPSetDescription (edm::ParameterSetDescription &pset)

static void	fillHistoPSetDescription (edm::ParameterSetDescription &pset)

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
void	analyze (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

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

void	bookNoBPTX (DQMStore::IBooker &, NoBPTXME &me, const std::string &histname, const std::string &histtitle, int nbins, double xmin, double xmax)

void	bookNoBPTX (DQMStore::IBooker &, NoBPTXME &me, const std::string &histname, const std::string &histtitle, const std::vector< double > &binningX)

void	bookNoBPTX (DQMStore::IBooker &, NoBPTXME &me, const std::string &histname, const std::string &histtitle, int nbinsX, double xmin, double xmax, double ymin, double ymax, bool bookDen)

void	bookNoBPTX (DQMStore::IBooker &, NoBPTXME &me, const std::string &histname, const std::string &histtitle, int nbinsX, double xmin, double xmax, int nbinsY, double ymin, double ymax)

void	bookNoBPTX (DQMStore::IBooker &, NoBPTXME &me, const std::string &histname, const std::string &histtitle, const std::vector< double > &binningX, const std::vector< double > &binningY)

void	setNoBPTXTitle (NoBPTXME &me, const std::string &titleX, const std::string &titleY, bool bookDen)

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)

Static Private Member Functions
static NoBPTXbinning	getHistoLSPSet (const edm::ParameterSet &pset)

static NoBPTXbinning	getHistoPSet (const edm::ParameterSet &pset)

Private Attributes
NoBPTXbinning	bx_binning_

std::unique_ptr< GenericTriggerEventFlag >	den_genTriggerEventFlag_

std::string	folderName_

std::string	histoSuffix_

NoBPTXbinning	jetE_binning_

std::vector< double >	jetE_variable_binning_

NoBPTXME	jetENoBPTX_

NoBPTXME	jetENoBPTX_variableBinning_

NoBPTXbinning	jetEta_binning_

NoBPTXME	jetEtaNoBPTX_

NoBPTXME	jetEtaVsBX_

NoBPTXME	jetEtaVsLS_

NoBPTXME	jetEVsBX_

NoBPTXME	jetEVsLS_

NoBPTXbinning	jetPhi_binning_

NoBPTXME	jetPhiNoBPTX_

NoBPTXME	jetPhiVsBX_

NoBPTXME	jetPhiVsLS_

StringCutObjectSelector< reco::CaloJet, true >	jetSelection_

edm::EDGetTokenT< reco::CaloJetCollection >	jetToken_

NoBPTXbinning	ls_binning_

NoBPTXbinning	muonEta_binning_

NoBPTXME	muonEtaNoBPTX_

NoBPTXME	muonEtaVsBX_

NoBPTXME	muonEtaVsLS_

NoBPTXbinning	muonPhi_binning_

NoBPTXME	muonPhiNoBPTX_

NoBPTXME	muonPhiVsBX_

NoBPTXME	muonPhiVsLS_

NoBPTXbinning	muonPt_binning_

std::vector< double >	muonPt_variable_binning_

NoBPTXME	muonPtNoBPTX_

NoBPTXME	muonPtNoBPTX_variableBinning_

NoBPTXME	muonPtVsBX_

NoBPTXME	muonPtVsLS_

StringCutObjectSelector< reco::Track, true >	muonSelection_

edm::EDGetTokenT< reco::TrackCollection >	muonToken_

unsigned int	njets_

unsigned int	nmuons_

std::unique_ptr< GenericTriggerEventFlag >	num_genTriggerEventFlag_

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

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 40 of file NoBPTXMonitor.h.

Constructor & Destructor Documentation

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

Definition at line 7 of file NoBPTXMonitor.cc.

References NoBPTXMonitor::NoBPTXME::denominator, jetENoBPTX_, jetENoBPTX_variableBinning_, jetEtaNoBPTX_, jetEtaVsBX_, jetEtaVsLS_, jetEVsBX_, jetEVsLS_, jetPhiNoBPTX_, jetPhiVsBX_, jetPhiVsLS_, muonEtaNoBPTX_, muonEtaVsBX_, muonEtaVsLS_, muonPhiNoBPTX_, muonPhiVsBX_, muonPhiVsLS_, muonPtNoBPTX_, muonPtNoBPTX_variableBinning_, muonPtVsBX_, muonPtVsLS_, NoBPTXMonitor::NoBPTXME::numerator, and ~NoBPTXMonitor().

     : folderName_(iConfig.getParameter<std::string>("FolderName")),
       jetToken_(consumes<reco::CaloJetCollection>(iConfig.getParameter<edm::InputTag>("jets"))),
       muonToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("muons"))),
       jetE_variable_binning_(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("jetEBinning")),
       jetE_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetEPSet"))),
       jetEta_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetEtaPSet"))),
       jetPhi_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("jetPhiPSet"))),
       muonPt_variable_binning_(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonPtBinning")),
       muonPt_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPtPSet"))),
       muonEta_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonEtaPSet"))),
       muonPhi_binning_(getHistoPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("muonPhiPSet"))),
       ls_binning_(
           getHistoPSet(iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("lsPSet"))),
       bx_binning_(getHistoLSPSet(
           iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>("bxPSet"))),
       num_genTriggerEventFlag_(new GenericTriggerEventFlag(
           iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this)),
       den_genTriggerEventFlag_(new GenericTriggerEventFlag(
           iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this)),
       jetSelection_(iConfig.getParameter<std::string>("jetSelection")),
       muonSelection_(iConfig.getParameter<std::string>("muonSelection")),
       njets_(iConfig.getParameter<unsigned int>("njets")),
       nmuons_(iConfig.getParameter<unsigned int>("nmuons")) {
   jetENoBPTX_.numerator = nullptr;
   jetENoBPTX_.denominator = nullptr;
   jetENoBPTX_variableBinning_.numerator = nullptr;
   jetENoBPTX_variableBinning_.denominator = nullptr;
   jetEVsLS_.numerator = nullptr;
   jetEVsLS_.denominator = nullptr;
   jetEVsBX_.numerator = nullptr;
   jetEtaNoBPTX_.numerator = nullptr;
   jetEtaNoBPTX_.denominator = nullptr;
   jetEtaVsLS_.numerator = nullptr;
   jetEtaVsBX_.numerator = nullptr;
   jetPhiNoBPTX_.numerator = nullptr;
   jetPhiNoBPTX_.denominator = nullptr;
   jetPhiVsLS_.numerator = nullptr;
   jetPhiVsBX_.numerator = nullptr;
 
   muonPtNoBPTX_.numerator = nullptr;
   muonPtNoBPTX_.denominator = nullptr;
   muonPtNoBPTX_variableBinning_.numerator = nullptr;
   muonPtNoBPTX_variableBinning_.denominator = nullptr;
   muonPtVsLS_.numerator = nullptr;
   muonPtVsBX_.numerator = nullptr;
   muonEtaNoBPTX_.numerator = nullptr;
   muonEtaNoBPTX_.denominator = nullptr;
   muonEtaVsLS_.numerator = nullptr;
   muonEtaVsBX_.numerator = nullptr;
   muonPhiNoBPTX_.numerator = nullptr;
   muonPhiNoBPTX_.denominator = nullptr;
   muonPhiVsLS_.numerator = nullptr;
   muonPhiVsBX_.numerator = nullptr;
 }

NoBPTXMonitor::~NoBPTXMonitor ( )

overridedefault

Referenced by NoBPTXMonitor().

Member Function Documentation

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 420 of file NoBPTXMonitor.cc.

References edm::EventBase::bunchCrossing(), l1GtPatternGenerator_cfi::bx, den_genTriggerEventFlag_, NoBPTXMonitor::NoBPTXME::denominator, dqm::impl::MonitorElement::Fill(), edm::Event::getByToken(), edm::EventBase::id(), dqmiolumiharvest::j, jetENoBPTX_, jetENoBPTX_variableBinning_, reco::btau::jetEta, jetEtaNoBPTX_, jetEtaVsBX_, jetEtaVsLS_, jetEVsBX_, jetEVsLS_, reco::btau::jetPhi, jetPhiNoBPTX_, jetPhiVsBX_, jetPhiVsLS_, singleTopDQM_cfi::jets, jetSelection_, jetToken_, eostools::ls(), edm::EventID::luminosityBlock(), visualization-live-secondInstance_cfg::m, HLTObjectMonitor_cfi::muonEta, muonEtaNoBPTX_, muonEtaVsBX_, muonEtaVsLS_, HLTObjectMonitor_cfi::muonPhi, muonPhiNoBPTX_, muonPhiVsBX_, muonPhiVsLS_, HLTObjectMonitor_cfi::muonPt, muonPtNoBPTX_, muonPtNoBPTX_variableBinning_, muonPtVsBX_, muonPtVsLS_, PDWG_BPHSkim_cff::muons, muonSelection_, muonToken_, njets_, nmuons_, num_genTriggerEventFlag_, and NoBPTXMonitor::NoBPTXME::numerator.

                                                                                {
   // Filter out events if Trigger Filtering is requested
   if (den_genTriggerEventFlag_->on() && !den_genTriggerEventFlag_->accept(iEvent, iSetup))
     return;
 
   int ls = iEvent.id().luminosityBlock();
   int bx = iEvent.bunchCrossing();
 
   edm::Handle<reco::CaloJetCollection> jetHandle;
   iEvent.getByToken(jetToken_, jetHandle);
   std::vector<reco::CaloJet> jets;
   if ((unsigned int)(jetHandle->size()) < njets_)
     return;
   for (auto const& j : *jetHandle) {
     if (jetSelection_(j))
       jets.push_back(j);
   }
   if ((unsigned int)(jets.size()) < njets_)
     return;
   double jetE = -999;
   double jetEta = -999;
   double jetPhi = -999;
   if (!jets.empty()) {
     jetE = jets[0].energy();
     jetEta = jets[0].eta();
     jetPhi = jets[0].phi();
   }
 
   edm::Handle<reco::TrackCollection> DSAHandle;
   iEvent.getByToken(muonToken_, DSAHandle);
   if ((unsigned int)(DSAHandle->size()) < nmuons_)
     return;
   std::vector<reco::Track> muons;
   for (auto const& m : *DSAHandle) {
     if (muonSelection_(m))
       muons.push_back(m);
   }
   if ((unsigned int)(muons.size()) < nmuons_)
     return;
   double muonPt = -999;
   double muonEta = -999;
   double muonPhi = -999;
   if (!muons.empty()) {
     muonPt = muons[0].pt();
     muonEta = muons[0].eta();
     muonPhi = muons[0].phi();
   }
 
   // filling histograms (denominator)
   jetENoBPTX_.denominator->Fill(jetE);
   jetENoBPTX_variableBinning_.denominator->Fill(jetE);
   jetEVsLS_.denominator->Fill(ls, jetE);
   jetEtaNoBPTX_.denominator->Fill(jetEta);
   jetPhiNoBPTX_.denominator->Fill(jetPhi);
   muonPtNoBPTX_.denominator->Fill(muonPt);
   muonPtNoBPTX_variableBinning_.denominator->Fill(muonPt);
   muonEtaNoBPTX_.denominator->Fill(muonEta);
   muonPhiNoBPTX_.denominator->Fill(muonPhi);
 
   // filling histograms (numerator)
   if (num_genTriggerEventFlag_->on() && !num_genTriggerEventFlag_->accept(iEvent, iSetup))
     return;
   jetENoBPTX_.numerator->Fill(jetE);
   jetENoBPTX_variableBinning_.numerator->Fill(jetE);
   jetEVsLS_.numerator->Fill(ls, jetE);
   jetEVsBX_.numerator->Fill(bx, jetE);
   jetEtaNoBPTX_.numerator->Fill(jetEta);
   jetEtaVsLS_.numerator->Fill(ls, jetEta);
   jetEtaVsBX_.numerator->Fill(bx, jetEta);
   jetPhiNoBPTX_.numerator->Fill(jetPhi);
   jetPhiVsLS_.numerator->Fill(ls, jetPhi);
   jetPhiVsBX_.numerator->Fill(bx, jetPhi);
   muonPtNoBPTX_.numerator->Fill(muonPt);
   muonPtNoBPTX_variableBinning_.numerator->Fill(muonPt);
   muonPtVsLS_.numerator->Fill(ls, muonPt);
   muonPtVsBX_.numerator->Fill(bx, muonPt);
   muonEtaNoBPTX_.numerator->Fill(muonEta);
   muonEtaVsLS_.numerator->Fill(ls, muonEta);
   muonEtaVsBX_.numerator->Fill(bx, muonEta);
   muonPhiNoBPTX_.numerator->Fill(muonPhi);
   muonPhiVsLS_.numerator->Fill(ls, muonPhi);
   muonPhiVsBX_.numerator->Fill(bx, muonPhi);
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 163 of file NoBPTXMonitor.cc.

References bookNoBPTX(), bx_binning_, den_genTriggerEventFlag_, folderName_, jetE_binning_, jetE_variable_binning_, jetENoBPTX_, jetENoBPTX_variableBinning_, jetEta_binning_, jetEtaNoBPTX_, jetEtaVsBX_, jetEtaVsLS_, jetEVsBX_, jetEVsLS_, jetPhi_binning_, jetPhiNoBPTX_, jetPhiVsBX_, jetPhiVsLS_, ls_binning_, muonEta_binning_, muonEtaNoBPTX_, muonEtaVsBX_, muonEtaVsLS_, muonPhi_binning_, muonPhiNoBPTX_, muonPhiVsBX_, muonPhiVsLS_, muonPt_binning_, muonPt_variable_binning_, muonPtNoBPTX_, muonPtNoBPTX_variableBinning_, muonPtVsBX_, muonPtVsLS_, NoBPTXMonitor::NoBPTXbinning::nbins, num_genTriggerEventFlag_, dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), setNoBPTXTitle(), AlCaHLTBitMon_QueryRunRegistry::string, NoBPTXMonitor::NoBPTXbinning::xmax, and NoBPTXMonitor::NoBPTXbinning::xmin.

                                                                                                             {
   std::string histname, histtitle;
   bool bookDen;
 
   std::string currentFolder = folderName_;
   ibooker.setCurrentFolder(currentFolder);
 
   histname = "jetE";
   histtitle = "jetE";
   bookDen = true;
   bookNoBPTX(ibooker, jetENoBPTX_, histname, histtitle, jetE_binning_.nbins, jetE_binning_.xmin, jetE_binning_.xmax);
   setNoBPTXTitle(jetENoBPTX_, "Jet E [GeV]", "Events / [GeV]", bookDen);
 
   histname = "jetE_variable";
   histtitle = "jetE";
   bookDen = true;
   bookNoBPTX(ibooker, jetENoBPTX_variableBinning_, histname, histtitle, jetE_variable_binning_);
   setNoBPTXTitle(jetENoBPTX_variableBinning_, "Jet E [GeV]", "Events / [GeV]", bookDen);
 
   histname = "jetEVsLS";
   histtitle = "jetE vs LS";
   bookDen = true;
   bookNoBPTX(ibooker,
              jetEVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              jetE_binning_.xmin,
              jetE_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetEVsLS_, "LS", "Jet E [GeV]", bookDen);
 
   histname = "jetEVsBX";
   histtitle = "jetE vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              jetEVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              jetE_binning_.xmin,
              jetE_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetEVsBX_, "BX", "Jet E [GeV]", bookDen);
 
   histname = "jetEta";
   histtitle = "jetEta";
   bookDen = true;
   bookNoBPTX(
       ibooker, jetEtaNoBPTX_, histname, histtitle, jetEta_binning_.nbins, jetEta_binning_.xmin, jetEta_binning_.xmax);
   setNoBPTXTitle(jetEtaNoBPTX_, "Jet #eta", "Events", bookDen);
 
   histname = "jetEtaVsLS";
   histtitle = "jetEta vs LS";
   bookDen = false;
   bookNoBPTX(ibooker,
              jetEtaVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              jetEta_binning_.xmin,
              jetEta_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetEtaVsLS_, "LS", "Jet #eta", bookDen);
 
   histname = "jetEtaVsBX";
   histtitle = "jetEta vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              jetEtaVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              jetEta_binning_.xmin,
              jetEta_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetEtaVsBX_, "BX", "Jet #eta", bookDen);
 
   histname = "jetPhi";
   histtitle = "jetPhi";
   bookDen = true;
   bookNoBPTX(
       ibooker, jetPhiNoBPTX_, histname, histtitle, jetPhi_binning_.nbins, jetPhi_binning_.xmin, jetPhi_binning_.xmax);
   setNoBPTXTitle(jetPhiNoBPTX_, "Jet #phi", "Events", bookDen);
 
   histname = "jetPhiVsLS";
   histtitle = "jetPhi vs LS";
   bookDen = false;
   bookNoBPTX(ibooker,
              jetPhiVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              jetPhi_binning_.xmin,
              jetPhi_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetPhiVsLS_, "LS", "Jet #phi", bookDen);
 
   histname = "jetPhiVsBX";
   histtitle = "jetPhi vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              jetPhiVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              jetPhi_binning_.xmin,
              jetPhi_binning_.xmax,
              bookDen);
   setNoBPTXTitle(jetPhiVsBX_, "BX", "Jet #phi", bookDen);
 
   histname = "muonPt";
   histtitle = "muonPt";
   bookDen = true;
   bookNoBPTX(
       ibooker, muonPtNoBPTX_, histname, histtitle, muonPt_binning_.nbins, muonPt_binning_.xmin, muonPt_binning_.xmax);
   setNoBPTXTitle(muonPtNoBPTX_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);
 
   histname = "muonPt_variable";
   histtitle = "muonPt";
   bookDen = true;
   bookNoBPTX(ibooker, muonPtNoBPTX_variableBinning_, histname, histtitle, muonPt_variable_binning_);
   setNoBPTXTitle(muonPtNoBPTX_variableBinning_, "DisplacedStandAlone Muon p_{T} [GeV]", "Events / [GeV]", bookDen);
 
   histname = "muonPtVsLS";
   histtitle = "muonPt vs LS";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonPtVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              muonPt_binning_.xmin,
              muonPt_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonPtVsLS_, "LS", "DisplacedStandAlone Muon p_{T} [GeV]", bookDen);
 
   histname = "muonPtVsBX";
   histtitle = "muonPt vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonPtVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              muonPt_binning_.xmin,
              muonPt_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonPtVsBX_, "BX", "DisplacedStandAlone Muon p_{T} [GeV]", bookDen);
 
   histname = "muonEta";
   histtitle = "muonEta";
   bookDen = true;
   bookNoBPTX(ibooker,
              muonEtaNoBPTX_,
              histname,
              histtitle,
              muonEta_binning_.nbins,
              muonEta_binning_.xmin,
              muonEta_binning_.xmax);
   setNoBPTXTitle(muonEtaNoBPTX_, "DisplacedStandAlone Muon #eta", "Events", bookDen);
 
   histname = "muonEtaVsLS";
   histtitle = "muonEta vs LS";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonEtaVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              muonEta_binning_.xmin,
              muonEta_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonEtaVsLS_, "LS", "DisplacedStandAlone Muon #eta", bookDen);
 
   histname = "muonEtaVsBX";
   histtitle = "muonEta vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonEtaVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              muonEta_binning_.xmin,
              muonEta_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonEtaVsBX_, "BX", "DisplacedStandAlone Muon #eta", bookDen);
 
   histname = "muonPhi";
   histtitle = "muonPhi";
   bookDen = true;
   bookNoBPTX(ibooker,
              muonPhiNoBPTX_,
              histname,
              histtitle,
              muonPhi_binning_.nbins,
              muonPhi_binning_.xmin,
              muonPhi_binning_.xmax);
   setNoBPTXTitle(muonPhiNoBPTX_, "DisplacedStandAlone Muon #phi", "Events", bookDen);
 
   histname = "muonPhiVsLS";
   histtitle = "muonPhi vs LS";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonPhiVsLS_,
              histname,
              histtitle,
              ls_binning_.nbins,
              ls_binning_.xmin,
              ls_binning_.xmax,
              muonPhi_binning_.xmin,
              muonPhi_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonPhiVsLS_, "LS", "DisplacedStandAlone Muon #phi", bookDen);
 
   histname = "muonPhiVsBX";
   histtitle = "muonPhi vs BX";
   bookDen = false;
   bookNoBPTX(ibooker,
              muonPhiVsBX_,
              histname,
              histtitle,
              bx_binning_.nbins,
              bx_binning_.xmin,
              bx_binning_.xmax,
              muonPhi_binning_.xmin,
              muonPhi_binning_.xmax,
              bookDen);
   setNoBPTXTitle(muonPhiVsBX_, "BX", "DisplacedStandAlone Muon #phi", bookDen);
 
   // Initialize the GenericTriggerEventFlag
   if (num_genTriggerEventFlag_ && num_genTriggerEventFlag_->on())
     num_genTriggerEventFlag_->initRun(iRun, iSetup);
   if (den_genTriggerEventFlag_ && den_genTriggerEventFlag_->on())
     den_genTriggerEventFlag_->initRun(iRun, iSetup);
 }

void NoBPTXMonitor::bookNoBPTX	(	DQMStore::IBooker &	ibooker,
		NoBPTXME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbins,
		double	xmin,
		double	xmax
	)

protected

Definition at line 94 of file NoBPTXMonitor.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), NoBPTXMonitor::NoBPTXME::denominator, and NoBPTXMonitor::NoBPTXME::numerator.

Referenced by bookHistograms().

                                            {
   me.numerator = ibooker.book1D(histname + "_numerator", histtitle + " (numerator)", nbins, min, max);
   me.denominator = ibooker.book1D(histname + "_denominator", histtitle + " (denominator)", nbins, min, max);
 }

void NoBPTXMonitor::bookNoBPTX	(	DQMStore::IBooker &	ibooker,
		NoBPTXME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		const std::vector< double > &	binningX
	)

protected

Definition at line 104 of file NoBPTXMonitor.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), NoBPTXMonitor::NoBPTXME::denominator, LaserClient_cfi::nbins, and NoBPTXMonitor::NoBPTXME::numerator.

                                                                  {
   int nbins = binning.size() - 1;
   std::vector<float> fbinning(binning.begin(), binning.end());
   float* arr = &fbinning[0];
   me.numerator = ibooker.book1D(histname + "_numerator", histtitle + " (numerator)", nbins, arr);
   me.denominator = ibooker.book1D(histname + "_denominator", histtitle + " (denominator)", nbins, arr);
 }

void NoBPTXMonitor::bookNoBPTX	(	DQMStore::IBooker &	ibooker,
		NoBPTXME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbinsX,
		double	xmin,
		double	xmax,
		double	ymin,
		double	ymax,
		bool	bookDen
	)

protected

Definition at line 115 of file NoBPTXMonitor.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::bookProfile(), NoBPTXMonitor::NoBPTXME::denominator, and NoBPTXMonitor::NoBPTXME::numerator.

                                              {
   me.numerator =
       ibooker.bookProfile(histname + "_numerator", histtitle + " (numerator)", nbinsX, xmin, xmax, ymin, ymax);
   if (bookDen)
     me.denominator =
         ibooker.bookProfile(histname + "_denominator", histtitle + " (denominator)", nbinsX, xmin, xmax, ymin, ymax);
 }

void NoBPTXMonitor::bookNoBPTX	(	DQMStore::IBooker &	ibooker,
		NoBPTXME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbinsX,
		double	xmin,
		double	xmax,
		int	nbinsY,
		double	ymin,
		double	ymax
	)

protected

Definition at line 131 of file NoBPTXMonitor.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), NoBPTXMonitor::NoBPTXME::denominator, and NoBPTXMonitor::NoBPTXME::numerator.

                                             {
   me.numerator =
       ibooker.book2D(histname + "_numerator", histtitle + " (numerator)", nbinsX, xmin, xmax, nbinsY, ymin, ymax);
   me.denominator =
       ibooker.book2D(histname + "_denominator", histtitle + " (denominator)", nbinsX, xmin, xmax, nbinsY, ymin, ymax);
 }

void NoBPTXMonitor::bookNoBPTX	(	DQMStore::IBooker &	ibooker,
		NoBPTXME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		const std::vector< double > &	binningX,
		const std::vector< double > &	binningY
	)

protected

Definition at line 146 of file NoBPTXMonitor.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), NoBPTXMonitor::NoBPTXME::denominator, hlt_dqm_clientPB-live_cfg::nbinsX, hlt_dqm_clientPB-live_cfg::nbinsY, and NoBPTXMonitor::NoBPTXME::numerator.

                                                                   {
   int nbinsX = binningX.size() - 1;
   std::vector<float> fbinningX(binningX.begin(), binningX.end());
   float* arrX = &fbinningX[0];
   int nbinsY = binningY.size() - 1;
   std::vector<float> fbinningY(binningY.begin(), binningY.end());
   float* arrY = &fbinningY[0];
 
   me.numerator = ibooker.book2D(histname + "_numerator", histtitle + " (numerator)", nbinsX, arrX, nbinsY, arrY);
   me.denominator = ibooker.book2D(histname + "_denominator", histtitle + " (denominator)", nbinsX, arrX, nbinsY, arrY);
 }

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

static

Definition at line 514 of file NoBPTXMonitor.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), trigObjTnPSource_cfi::bins, NoBPTXMonitor_cfi::bxPSet, DEFINE_FWK_MODULE, fillHistoLSPSetDescription(), fillHistoPSetDescription(), SiStripSourceConfigTier0_cff::genericTriggerEventPSet, LumiMonitor_cff::histoPSet, HLT_2018_cff::InputTag, NoBPTXMonitor_cfi::jetEPSet, NoBPTXMonitor_cfi::jetEtaPSet, NoBPTXMonitor_cfi::jetPhiPSet, LumiMonitor_cff::lsPSet, DiDispStaMuonMonitor_cfi::muonEtaPSet, DiDispStaMuonMonitor_cfi::muonPhiPSet, DiDispStaMuonMonitor_cfi::muonPtPSet, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("FolderName", "HLT/NoBPTX");
 
   desc.add<edm::InputTag>("jets", edm::InputTag("ak4CaloJets"));
   desc.add<edm::InputTag>("muons", edm::InputTag("displacedStandAloneMuons"));
   desc.add<std::string>("jetSelection", "pt > 0");
   desc.add<std::string>("muonSelection", "pt > 0");
   desc.add<unsigned int>("njets", 0);
   desc.add<unsigned int>("nmuons", 0);
 
   edm::ParameterSetDescription genericTriggerEventPSet;
   genericTriggerEventPSet.add<bool>("andOr");
   genericTriggerEventPSet.add<edm::InputTag>("dcsInputTag", edm::InputTag("scalersRawToDigi"));
   genericTriggerEventPSet.add<std::vector<int> >("dcsPartitions", {});
   genericTriggerEventPSet.add<bool>("andOrDcs", false);
   genericTriggerEventPSet.add<bool>("errorReplyDcs", true);
   genericTriggerEventPSet.add<std::string>("dbLabel", "");
   genericTriggerEventPSet.add<bool>("andOrHlt", true);
   genericTriggerEventPSet.add<edm::InputTag>("hltInputTag", edm::InputTag("TriggerResults::HLT"));
   genericTriggerEventPSet.add<std::vector<std::string> >("hltPaths", {});
   genericTriggerEventPSet.add<std::string>("hltDBKey", "");
   genericTriggerEventPSet.add<bool>("errorReplyHlt", false);
   genericTriggerEventPSet.add<unsigned int>("verbosityLevel", 1);
 
   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
 
   edm::ParameterSetDescription histoPSet;
   edm::ParameterSetDescription jetEPSet;
   edm::ParameterSetDescription jetEtaPSet;
   edm::ParameterSetDescription jetPhiPSet;
   edm::ParameterSetDescription muonPtPSet;
   edm::ParameterSetDescription muonEtaPSet;
   edm::ParameterSetDescription muonPhiPSet;
   edm::ParameterSetDescription lsPSet;
   edm::ParameterSetDescription bxPSet;
   fillHistoPSetDescription(jetEPSet);
   fillHistoPSetDescription(jetEtaPSet);
   fillHistoPSetDescription(jetPhiPSet);
   fillHistoPSetDescription(muonPtPSet);
   fillHistoPSetDescription(muonEtaPSet);
   fillHistoPSetDescription(muonPhiPSet);
   fillHistoPSetDescription(lsPSet);
   fillHistoLSPSetDescription(bxPSet);
   histoPSet.add<edm::ParameterSetDescription>("jetEPSet", jetEPSet);
   histoPSet.add<edm::ParameterSetDescription>("jetEtaPSet", jetEtaPSet);
   histoPSet.add<edm::ParameterSetDescription>("jetPhiPSet", jetPhiPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonPtPSet", muonPtPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonEtaPSet", muonEtaPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonPhiPSet", muonPhiPSet);
   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
   histoPSet.add<edm::ParameterSetDescription>("bxPSet", bxPSet);
   std::vector<double> bins = {0.,   20.,  40.,  60.,  80.,  90.,  100., 110., 120., 130., 140., 150., 160.,
                               170., 180., 190., 200., 220., 240., 260., 280., 300., 350., 400., 450., 1000.};
   histoPSet.add<std::vector<double> >("jetEBinning", bins);
   histoPSet.add<std::vector<double> >("muonPtBinning", bins);
 
   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
 
   descriptions.add("NoBPTXMonitoring", desc);
 }

void NoBPTXMonitor::fillHistoLSPSetDescription ( edm::ParameterSetDescription & pset )

static

Definition at line 510 of file NoBPTXMonitor.cc.

References edm::ParameterSetDescription::add().

Referenced by fillDescriptions().

                                                                                {
   pset.add<unsigned int>("nbins", 2000);
 }

void NoBPTXMonitor::fillHistoPSetDescription ( edm::ParameterSetDescription & pset )

static

Definition at line 504 of file NoBPTXMonitor.cc.

References edm::ParameterSetDescription::add().

Referenced by fillDescriptions().

                                                                              {
   pset.add<unsigned int>("nbins", 200);
   pset.add<double>("xmin", -0.5);
   pset.add<double>("xmax", 19999.5);
 }

NoBPTXMonitor::NoBPTXbinning NoBPTXMonitor::getHistoLSPSet ( const edm::ParameterSet & pset )

staticprivate

Definition at line 81 of file NoBPTXMonitor.cc.

References edm::ParameterSet::getParameter().

                                                                                     {
   return NoBPTXbinning{pset.getParameter<unsigned int>("nbins"), 0., double(pset.getParameter<unsigned int>("nbins"))};
 }

NoBPTXMonitor::NoBPTXbinning NoBPTXMonitor::getHistoPSet ( const edm::ParameterSet & pset )

staticprivate

Definition at line 73 of file NoBPTXMonitor.cc.

References edm::ParameterSet::getParameter().

                                                                                   {
   return NoBPTXbinning{
       pset.getParameter<unsigned int>("nbins"),
       pset.getParameter<double>("xmin"),
       pset.getParameter<double>("xmax"),
   };
 }

void NoBPTXMonitor::setNoBPTXTitle	(	NoBPTXME &	me,
		const std::string &	titleX,
		const std::string &	titleY,
		bool	bookDen
	)

protected

Definition at line 85 of file NoBPTXMonitor.cc.

References NoBPTXMonitor::NoBPTXME::denominator, NoBPTXMonitor::NoBPTXME::numerator, and dqm::impl::MonitorElement::setAxisTitle().

Referenced by bookHistograms().

                                                                                                                {
   me.numerator->setAxisTitle(titleX, 1);
   me.numerator->setAxisTitle(titleY, 2);
   if (bookDen) {
     me.denominator->setAxisTitle(titleX, 1);
     me.denominator->setAxisTitle(titleY, 2);
   }
 }