#include <MuonMonitor.h>

Inheritance diagram for MuonMonitor:

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

	~MuonMonitor () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override

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

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

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

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

void	endRun (edm::Run const &run, edm::EventSetup const &setup) override

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

	~DQMEDAnalyzer () override=default

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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

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)

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	bookME (DQMStore::IBooker &, MuonME &me, const std::string &histname, const std::string &histtitle, int nbins, double xmin, double xmax)

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

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

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

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

void	setTitle (MuonME &me, const std::string &titleX, const std::string &titleY)

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 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 MEbinning	getHistoLSPSet (edm::ParameterSet const &pset)

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

Private Attributes
std::unique_ptr< GenericTriggerEventFlag >	den_genTriggerEventFlag_

const MEbinning	dxy_binning_

MuonME	eleEta_muEta_

std::vector< double >	eleEta_variable_binning_2D_

MuonME	eleEtaME_

MuonME	eleME_variableBinning_

MuonME	elePt_muPt_

std::vector< double >	elePt_variable_binning_2D_

StringCutObjectSelector< reco::GsfElectron, true >	eleSelection_

edm::EDGetTokenT< edm::View< reco::GsfElectron > >	eleToken_

const MEbinning	eta_binning_

std::string	folderName_

std::string	histoSuffix_

MEbinning	ls_binning_

StringCutObjectSelector< reco::MET, true >	metSelection_

edm::EDGetTokenT< reco::PFMETCollection >	metToken_

std::vector< double >	muEta_variable_binning_2D_

MEbinning	muon_binning_

std::vector< double >	muon_variable_binning_

MuonME	muondxy_

MuonME	muondz_

std::vector< double >	muoneta_variable_binning_

MuonME	muonEtaME_

MuonME	muonEtaME_variableBinning_

MuonME	muonEtaPhiME_

MuonME	muonME_

MuonME	muonME_variableBinning_

MuonME	muonPhiME_

StringCutObjectSelector< reco::Muon, true >	muonSelection_

edm::EDGetTokenT< reco::MuonCollection >	muonToken_

MuonME	muonVsLS_

std::vector< double >	muPt_variable_binning_2D_

unsigned int	nelectrons_

unsigned int	njets_

unsigned int	nmuons_

std::unique_ptr< GenericTriggerEventFlag >	num_genTriggerEventFlag_

const MEbinning	phi_binning_

edm::EDGetTokenT< reco::VertexCollection >	vtxToken_

Static Private Attributes
static double	MAX_dxy = 2.5

static double	MAX_ETA = 2.4

static double	MAX_PHI = 3.2

static int	N_dxy = 50

static int	N_ETA = 68

static int	N_PHI = 64

Additional Inherited Members
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 58 of file MuonMonitor.h.

Constructor & Destructor Documentation

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

Definition at line 12 of file MuonMonitor.cc.

References MuonME::denominator, eleEta_muEta_, eleEtaME_, eleME_variableBinning_, elePt_muPt_, muondxy_, muondz_, muonEtaME_, muonEtaME_variableBinning_, muonEtaPhiME_, muonME_, muonME_variableBinning_, muonPhiME_, muonVsLS_, MuonME::numerator, and ~MuonMonitor().

                                                          :
   folderName_             ( iConfig.getParameter<std::string>("FolderName") )
   , metToken_             ( consumes<reco::PFMETCollection>      (iConfig.getParameter<edm::InputTag>("met")       ) )
   , muonToken_             ( mayConsume<reco::MuonCollection>      (iConfig.getParameter<edm::InputTag>("muons")      ) )
   , vtxToken_             ( mayConsume<reco::VertexCollection>      (iConfig.getParameter<edm::InputTag>("vertices")      ) )
   , eleToken_             ( mayConsume<edm::View<reco::GsfElectron> >      (iConfig.getParameter<edm::InputTag>("electrons")      ) )
   , muon_variable_binning_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonBinning") )
   , muoneta_variable_binning_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muonetaBinning") )
   , muon_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("muonPSet")    ) )
   , ls_binning_           ( getHistoPSet (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("lsPSet")     ) )
   , muPt_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muPtBinning2D") )
   , elePt_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("elePtBinning2D") )
   , muEta_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("muEtaBinning2D") )
   , eleEta_variable_binning_2D_ ( iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<std::vector<double> >("eleEtaBinning2D") )
   , num_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"), consumesCollector(), *this))
   , den_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"), consumesCollector(), *this))
   , metSelection_ ( iConfig.getParameter<std::string>("metSelection") )
   , muonSelection_ ( iConfig.getParameter<std::string>("muonSelection") )
   , eleSelection_ ( iConfig.getParameter<std::string>("eleSelection") )
   , nmuons_      ( iConfig.getParameter<unsigned int>("nmuons" )      )
   , nelectrons_      ( iConfig.getParameter<unsigned int>("nelectrons" )      )
 {
 
   muonME_.numerator   = nullptr;
   muonME_.denominator = nullptr;
   muonME_variableBinning_.numerator   = nullptr;
   muonME_variableBinning_.denominator = nullptr;
   muonVsLS_.numerator   = nullptr;
   muonVsLS_.denominator = nullptr;
   muonEtaME_.numerator   = nullptr;
   muonEtaME_.denominator = nullptr;
   muonEtaME_variableBinning_.numerator   = nullptr;
   muonEtaME_variableBinning_.denominator = nullptr;
   muonPhiME_.numerator   = nullptr;
   muonPhiME_.denominator = nullptr;
   muonEtaPhiME_.numerator   = nullptr;
   muonEtaPhiME_.denominator = nullptr;
   muondxy_.denominator = nullptr;
   muondxy_.numerator = nullptr;
   muondz_.denominator = nullptr;
   muondz_.numerator = nullptr;
   eleME_variableBinning_.numerator   = nullptr;
   eleME_variableBinning_.denominator = nullptr;
   eleEtaME_.numerator   = nullptr;
   eleEtaME_.denominator = nullptr;
   elePt_muPt_.numerator = nullptr;
   elePt_muPt_.denominator = nullptr;
   eleEta_muEta_.numerator = nullptr;
   eleEta_muEta_.denominator = nullptr;
 
 }

MuonMonitor::~MuonMonitor ( )

overridedefault

Referenced by MuonMonitor().

Member Function Documentation

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 209 of file MuonMonitor.cc.

References den_genTriggerEventFlag_, MuonME::denominator, PVValHelper::dxy, PVValHelper::dz, MillePedeFileConverter_cfg::e, nano_cff::electrons, eleEta_muEta_, eleEtaME_, eleME_variableBinning_, elePt_muPt_, eleSelection_, eleToken_, PVValHelper::eta, MonitorElement::Fill(), HcalObjRepresent::Fill(), edm::Event::getByToken(), edm::EventBase::id(), eostools::ls(), edm::EventID::luminosityBlock(), metSelection_, metToken_, muondxy_, muondz_, muonEtaME_, muonEtaPhiME_, muonME_, muonME_variableBinning_, muonPhiME_, extraflags_cff::muons, muonSelection_, muonToken_, muonVsLS_, nelectrons_, nmuons_, num_genTriggerEventFlag_, MuonME::numerator, AlCaHLTBitMon_ParallelJobs::p, phi, EnergyCorrector::pt, MetAnalyzer::pv(), findQualityFiles::v, and vtxToken_.

                                                                               {
 
   // Filter out events if Trigger Filtering is requested
   if (den_genTriggerEventFlag_->on() && ! den_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
 
   edm::Handle<reco::PFMETCollection> metHandle;
   iEvent.getByToken( metToken_, metHandle );
   reco::PFMET pfmet = metHandle->front();
   if ( ! metSelection_( pfmet ) ) return;
 
   edm::Handle<reco::VertexCollection> vtxHandle;
   iEvent.getByToken(vtxToken_, vtxHandle);
 
   math::XYZPoint pv(0, 0, 0);
   for (reco::Vertex const & v: *vtxHandle) {
     if (not v.isFake()) {
       pv.SetXYZ(v.x(), v.y(), v.z());
       break;
     }
   }
 
   edm::Handle<reco::MuonCollection> muonHandle;
   iEvent.getByToken( muonToken_, muonHandle );
   std::vector<reco::Muon> muons;
   if ( muonHandle->size() < nmuons_ ) return;
   for ( auto const & p : *muonHandle ) {
     if ( muonSelection_( p ) ) muons.push_back(p);
   }
   if ( muons.size() < nmuons_ ) return;
 
   edm::Handle<edm::View<reco::GsfElectron> > eleHandle;
   iEvent.getByToken( eleToken_, eleHandle );
   std::vector<reco::GsfElectron> electrons;
   if ( eleHandle->size() < nelectrons_ ) return;
   for ( auto const & e : *eleHandle ) {
     if ( eleSelection_( e )) electrons.push_back(e);
   }
   if ( electrons.size() < nelectrons_ ) return;
 
   // filling histograms (denominator)
   int ls = iEvent.id().luminosityBlock();
   if(!muons.empty())
 
   {
     muonME_.denominator -> Fill(muons[0].pt());
     muonME_variableBinning_.denominator -> Fill(muons[0].pt());
     muonPhiME_.denominator->Fill(muons[0].phi());
     muonEtaME_.denominator->Fill(muons[0].eta());
     muonVsLS_.denominator -> Fill(ls, muons[0].pt());
     muonEtaPhiME_.denominator -> Fill(muons[0].eta(), muons[0].phi());
     muondxy_.denominator -> Fill(muons[0].muonBestTrack()->dxy(pv));
     muondz_.denominator -> Fill(muons[0].muonBestTrack()->dz(pv));
     if(!electrons.empty())
     {
       eleME_variableBinning_.denominator -> Fill(electrons[0].pt());
       eleEtaME_.denominator->Fill(electrons[0].eta());
       eleEta_muEta_.denominator->Fill(electrons[0].eta(), muons[0].eta());
       elePt_muPt_.denominator->Fill(electrons[0].pt(), muons[0].pt());
     }
 
   }
 
   // applying selection for numerator
   if (num_genTriggerEventFlag_->on() && ! num_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
 
   // filling histograms (num_genTriggerEventFlag_)
   if(!muons.empty())
   {
     muonME_.numerator -> Fill(muons[0].pt());
     muonME_variableBinning_.numerator -> Fill(muons[0].pt());
     muonPhiME_.numerator->Fill(muons[0].phi());
     muonEtaME_.numerator->Fill(muons[0].eta());
     muonVsLS_.numerator -> Fill(ls, muons[0].pt());
     muonEtaPhiME_.numerator -> Fill(muons[0].eta(), muons[0].phi());
     muondxy_.numerator -> Fill(muons[0].muonBestTrack()->dxy(pv));
     muondz_.numerator -> Fill(muons[0].muonBestTrack()->dz(pv));
     if(!electrons.empty())
     {
       eleME_variableBinning_.numerator -> Fill(electrons[0].pt());
       eleEtaME_.numerator->Fill(electrons[0].eta());
       eleEta_muEta_.numerator->Fill(electrons[0].eta(), muons[0].eta());
       elePt_muPt_.numerator->Fill(electrons[0].pt(), muons[0].pt());
     }
 
   }
 
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 132 of file MuonMonitor.cc.

References bookME(), den_genTriggerEventFlag_, dxy_binning_, eleEta_muEta_, eleEta_variable_binning_2D_, eleEtaME_, eleME_variableBinning_, elePt_muPt_, elePt_variable_binning_2D_, eta_binning_, folderName_, ls_binning_, muEta_variable_binning_2D_, muon_binning_, muon_variable_binning_, muondxy_, muondz_, muoneta_variable_binning_, muonEtaME_, muonEtaME_variableBinning_, muonEtaPhiME_, muonME_, muonME_variableBinning_, muonPhiME_, muonVsLS_, muPt_variable_binning_2D_, num_genTriggerEventFlag_, phi_binning_, DQMStore::IBooker::setCurrentFolder(), setTitle(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   std::string histname, histtitle;
 
   ibooker.setCurrentFolder(folderName_);
 
   histname = "muon_pt"; histtitle = "muon PT";
   bookME(ibooker, muonME_, histname, histtitle, muon_binning_.nbins, muon_binning_.xmin, muon_binning_.xmax);
   setTitle(muonME_,"Muon pT [GeV]","events / [GeV]");
 
   histname = "muon_pt_variable"; histtitle = "muon PT";
   bookME(ibooker, muonME_variableBinning_, histname, histtitle, muon_variable_binning_);
   setTitle(muonME_variableBinning_,"Muon pT [GeV]","events / [GeV]");
 
   histname = "muonVsLS"; histtitle = "muon pt vs LS";
   bookME(ibooker, muonVsLS_, histname, histtitle, ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax, muon_binning_.xmin, muon_binning_.xmax);
   setTitle(muonVsLS_,"LS","Muon pT [GeV]");
 
   histname = "muon_phi"; histtitle = "Muon phi";
   bookME(ibooker, muonPhiME_, histname, histtitle, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
   setTitle(muonPhiME_,"Muon #phi","events / 0.1 rad");
 
 
   histname = "muon_eta"; histtitle = "Muon eta";
   bookME(ibooker, muonEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
   setTitle(muonEtaME_,"Muon #eta","events");
 
 
   histname = "muon_eta_variablebinning"; histtitle = "Muon eta";
   bookME(ibooker, muonEtaME_variableBinning_, histname, histtitle, muoneta_variable_binning_);
   setTitle(muonEtaME_variableBinning_,"Muon #eta","events");
 
   histname = "muon_dxy"; histtitle = "Muon dxy";
   bookME(ibooker, muondxy_, histname, histtitle, dxy_binning_.nbins, dxy_binning_.xmin, dxy_binning_.xmax);
   setTitle(muondxy_,"Muon #dxy","events");
 
   histname = "muon_dz"; histtitle = "Muon dz";
   bookME(ibooker, muondz_, histname, histtitle, dxy_binning_.nbins, dxy_binning_.xmin, dxy_binning_.xmax);
   setTitle(muondz_,"Muon #dz","events");
 
 
   histname = "muon_etaphi"; histtitle = "Muon eta-phi";
   bookME(ibooker, muonEtaPhiME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax, phi_binning_.nbins, phi_binning_.xmin, phi_binning_.xmax);
   setTitle(muonEtaPhiME_,"#eta","#phi");
 
   histname = "electron_pt_variable"; histtitle = "electron PT";
   bookME(ibooker, eleME_variableBinning_, histname, histtitle, muon_variable_binning_);
   setTitle(eleME_variableBinning_,"Electron pT [GeV]","events / [GeV]");
 
   histname = "electron_eta"; histtitle = "electron eta";
   bookME(ibooker, eleEtaME_, histname, histtitle, eta_binning_.nbins, eta_binning_.xmin, eta_binning_.xmax);
   setTitle(eleEtaME_,"Electron #eta","events");
 
   histname = "elePt_muPt"; histtitle = "electron pt vs muon pt";
   bookME(ibooker, elePt_muPt_, histname, histtitle, elePt_variable_binning_2D_, muPt_variable_binning_2D_);
   setTitle(elePt_muPt_,"electron pt [GeV]","muon pt [GeV]");
 
   histname = "eleEta_muEta"; histtitle = "electron #eta vs muon #eta";
   bookME(ibooker, eleEta_muEta_, histname, histtitle, eleEta_variable_binning_2D_, muEta_variable_binning_2D_);
   setTitle(eleEta_muEta_,"electron #eta","muon #eta");
 
 
 
 
 
   // 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 MuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		MuonME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbins,
		double	xmin,
		double	xmax
	)

protected

Definition at line 92 of file MuonMonitor.cc.

References DQMStore::IBooker::book1D(), MuonME::denominator, and MuonME::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 MuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		MuonME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		const std::vector< double > &	binningX
	)

protected

Definition at line 98 of file MuonMonitor.cc.

References DQMStore::IBooker::book1D(), MuonME::denominator, pileupCalc::nbins, and MuonME::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 MuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		MuonME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbinsX,
		double	xmin,
		double	xmax,
		double	ymin,
		double	ymax
	)

protected

Definition at line 107 of file MuonMonitor.cc.

References DQMStore::IBooker::bookProfile(), MuonME::denominator, and MuonME::numerator.

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

void MuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		MuonME &	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 113 of file MuonMonitor.cc.

References DQMStore::IBooker::book2D(), MuonME::denominator, and MuonME::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 MuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		MuonME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		const std::vector< double > &	binningX,
		const std::vector< double > &	binningY
	)

protected

Definition at line 119 of file MuonMonitor.cc.

References DQMStore::IBooker::book2D(), MuonME::denominator, and MuonME::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 MuonMonitor::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 311 of file MuonMonitor.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), create_public_pileup_plots::bins, DEFINE_FWK_MODULE, fillHistoLSPSetDescription(), fillHistoPSetDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   edm::ParameterSetDescription desc;
   desc.add<std::string>  ( "FolderName", "HLT/Muon" );
   desc.add<edm::InputTag>( "met",      edm::InputTag("pfMet") );
   desc.add<edm::InputTag>( "muons", edm::InputTag("muons") );
   desc.add<edm::InputTag>( "vertices", edm::InputTag("offlinePrimaryVertices") );
   desc.add<edm::InputTag>( "electrons", edm::InputTag("gedGsfElectrons") );
   desc.add<std::string>("metSelection", "pt > 0");
   desc.add<std::string>("muonSelection", "pt > 6 && eta<2.4 ");
   desc.add<std::string>("eleSelection", "pt > 0");
   //desc.add<std::string>("muonSelection", "pt > 145");
   desc.add<unsigned int>("nmuons",     0);
   desc.add<unsigned int>("nelectrons",     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<bool>("errorReplyL1", false);
   genericTriggerEventPSet.add<unsigned int>("verbosityLevel", 1);
   genericTriggerEventPSet.add<bool>("andOrL1", false);
   genericTriggerEventPSet.add<bool>("l1BeforeMask", false);
   genericTriggerEventPSet.add<std::vector<std::string> >("l1Algorithms",{});
 
   desc.add<edm::ParameterSetDescription>("numGenericTriggerEventPSet", genericTriggerEventPSet);
   desc.add<edm::ParameterSetDescription>("denGenericTriggerEventPSet", genericTriggerEventPSet);
 
   edm::ParameterSetDescription histoPSet;
   edm::ParameterSetDescription metPSet;
   fillHistoPSetDescription(metPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonPSet", metPSet);
   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> >("muonBinning", bins);
 
   std::vector<double> etabins = {-3.,-2.5,-2.,-1.5,-1.,-.5, 0.,.5, 1., 1.5, 2., 2.5, 3.};
   histoPSet.add<std::vector<double> >("muonetaBinning", etabins);
 
   std::vector<double> bins_2D = {0., 40., 80., 100., 120., 140., 160., 180., 200., 240., 280., 350., 450., 1000.};
   std::vector<double> eta_bins_2D = {-3.,-2.,-1., 0., 1., 2., 3.};
   std::vector<double> phi_bins_2D = {-3.1415,-2.5132,-1.8849,-1.2566,-0.6283, 0, 0.6283, 1.2566, 1.8849, 2.5132, 3.1415};
   histoPSet.add<std::vector<double> >("elePtBinning2D", bins_2D);
   histoPSet.add<std::vector<double> >("muPtBinning2D", bins_2D);
   histoPSet.add<std::vector<double> >("eleEtaBinning2D", eta_bins_2D);
   histoPSet.add<std::vector<double> >("muEtaBinning2D", eta_bins_2D);
 
   edm::ParameterSetDescription lsPSet;
   fillHistoLSPSetDescription(lsPSet);
   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
 
   desc.add<edm::ParameterSetDescription>("histoPSet", histoPSet);
 
   descriptions.add("muonMonitoring", desc);
 }

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

static

Definition at line 304 of file MuonMonitor.cc.

References edm::ParameterSetDescription::add().

Referenced by fillDescriptions().

 {
   pset.add<unsigned int>   ( "nbins", 2500 );
   pset.add<double>         ( "xmin",     0.);
   pset.add<double>         ( "xmax",  2500.);
 }

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

static

Definition at line 297 of file MuonMonitor.cc.

References edm::ParameterSetDescription::add().

Referenced by fillDescriptions().

 {
   pset.add<unsigned int>   ( "nbins");
   pset.add<double>         ( "xmin" );
   pset.add<double>         ( "xmax" );
 }

MEbinning MuonMonitor::getHistoLSPSet ( edm::ParameterSet const & pset )

staticprivate

Definition at line 75 of file MuonMonitor.cc.

References edm::ParameterSet::getParameter().

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

MEbinning MuonMonitor::getHistoPSet ( edm::ParameterSet const & pset )

staticprivate

Definition at line 66 of file MuonMonitor.cc.

References edm::ParameterSet::getParameter().

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

void MuonMonitor::setTitle	(	MuonME &	me,
		const std::string &	titleX,
		const std::string &	titleY
	)

protected

Definition at line 84 of file MuonMonitor.cc.

References MuonME::denominator, MuonME::numerator, and MonitorElement::setAxisTitle().

Referenced by bookHistograms(), Vispa.Gui.PortWidget.PortWidget::setName(), and Vispa.Views.LineDecayView.LineDecayContainer::setPxlObject().

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