#include <DiDispStaMuonMonitor.h>

Inheritance diagram for DiDispStaMuonMonitor:

Classes
struct	DiDispStaMuonME

struct	MEbinning

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

	~DiDispStaMuonMonitor () override

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

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

static void	fillHistoLSPSetDescription (edm::ParameterSetDescription &pset)

static void	fillHistoPSetDescription (edm::ParameterSetDescription &pset)

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 &, DiDispStaMuonME &me, const std::string &histname, const std::string &histtitle, int nbins, double xmin, double xmax)

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

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

void	bookME (DQMStore::IBooker &, DiDispStaMuonME &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 &, DiDispStaMuonME &me, const std::string &histname, const std::string &histtitle, const std::vector< double > &binningX, const std::vector< double > &binningY)

void	setTitle (DiDispStaMuonME &me, const std::string &titleX, const std::string &titleY, bool bookDen)

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

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

Private Attributes
std::unique_ptr< GenericTriggerEventFlag >	den_genTriggerEventFlag_

std::string	folderName_

std::string	histoSuffix_

MEbinning	ls_binning_

MEbinning	muonDxy_binning_

DiDispStaMuonME	muonDxyME_

MEbinning	muonEta_binning_

DiDispStaMuonME	muonEtaME_

MEbinning	muonPhi_binning_

DiDispStaMuonME	muonPhiME_

MEbinning	muonPt_binning_

std::vector< double >	muonPt_variable_binning_

DiDispStaMuonME	muonPtME_

DiDispStaMuonME	muonPtME_variableBinning_

DiDispStaMuonME	muonPtNoDxyCutME_

DiDispStaMuonME	muonPtVsLS_

StringCutObjectSelector< reco::Track, true >	muonSelectionDxy_

StringCutObjectSelector< reco::Track, true >	muonSelectionGeneral_

StringCutObjectSelector< reco::Track, true >	muonSelectionPt_

edm::EDGetTokenT< reco::TrackCollection >	muonToken_

unsigned int	nmuons_

std::unique_ptr< GenericTriggerEventFlag >	num_genTriggerEventFlag_

DiDispStaMuonME	subMuonDxyME_

DiDispStaMuonME	subMuonEtaME_

DiDispStaMuonME	subMuonPhiME_

DiDispStaMuonME	subMuonPtME_

DiDispStaMuonME	subMuonPtME_variableBinning_

Detailed Description

Definition at line 40 of file DiDispStaMuonMonitor.h.

Constructor & Destructor Documentation

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

Definition at line 7 of file DiDispStaMuonMonitor.cc.

References DiDispStaMuonMonitor::DiDispStaMuonME::denominator, muonDxyME_, muonEtaME_, muonPhiME_, muonPtME_, muonPtME_variableBinning_, muonPtNoDxyCutME_, muonPtVsLS_, DiDispStaMuonMonitor::DiDispStaMuonME::numerator, subMuonDxyME_, subMuonEtaME_, subMuonPhiME_, subMuonPtME_, subMuonPtME_variableBinning_, and ~DiDispStaMuonMonitor().

                                                                            :
   folderName_             ( iConfig.getParameter<std::string>("FolderName") )
   , muonToken_             ( consumes<reco::TrackCollection>       (iConfig.getParameter<edm::InputTag>("muons")     ) )
   , 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")    ) )
   , muonDxy_binning_          ( getHistoPSet   (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("muonDxyPSet")    ) )
   , ls_binning_           ( getHistoPSet (iConfig.getParameter<edm::ParameterSet>("histoPSet").getParameter<edm::ParameterSet>   ("lsPSet")     ) )
   , num_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("numGenericTriggerEventPSet"),consumesCollector(), *this))
   , den_genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("denGenericTriggerEventPSet"),consumesCollector(), *this))
   , muonSelectionGeneral_ ( iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("general") )
   , muonSelectionPt_ ( iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("pt") )
   , muonSelectionDxy_ ( iConfig.getParameter<edm::ParameterSet>("muonSelection").getParameter<std::string>("dxy") )
   , nmuons_     ( iConfig.getParameter<unsigned int>("nmuons" )     )
 {
 
   muonPtME_.numerator   = nullptr;
   muonPtME_.denominator = nullptr;
   muonPtNoDxyCutME_.numerator   = nullptr;
   muonPtNoDxyCutME_.denominator = nullptr;
   muonPtME_variableBinning_.numerator   = nullptr;
   muonPtME_variableBinning_.denominator = nullptr;
   muonPtVsLS_.numerator   = nullptr;
   muonPtVsLS_.denominator   = nullptr;
   muonEtaME_.numerator   = nullptr;
   muonEtaME_.denominator = nullptr;
   muonPhiME_.numerator   = nullptr;
   muonPhiME_.denominator = nullptr;
   muonDxyME_.numerator   = nullptr;
   muonDxyME_.denominator = nullptr;
 
 
   subMuonPtME_.numerator   = nullptr;
   subMuonPtME_.denominator = nullptr;
   subMuonPtME_variableBinning_.numerator   = nullptr;
   subMuonPtME_variableBinning_.denominator = nullptr;
   subMuonEtaME_.numerator   = nullptr;
   subMuonEtaME_.denominator = nullptr;
   subMuonPhiME_.numerator   = nullptr;
   subMuonPhiME_.denominator = nullptr;
   subMuonDxyME_.numerator   = nullptr;
   subMuonDxyME_.denominator = nullptr;
 
 
 }

DiDispStaMuonMonitor::~DiDispStaMuonMonitor ( )

overridedefault

Referenced by DiDispStaMuonMonitor().

Member Function Documentation

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

overrideprotected

Definition at line 207 of file DiDispStaMuonMonitor.cc.

References den_genTriggerEventFlag_, DiDispStaMuonMonitor::DiDispStaMuonME::denominator, PVValHelper::dxy, PVValHelper::eta, MonitorElement::Fill(), edm::Event::getByToken(), mps_fire::i, edm::EventBase::id(), eostools::ls(), edm::EventID::luminosityBlock(), funct::m, muonDxyME_, muonEtaME_, muonPhiME_, muonPtME_, muonPtME_variableBinning_, muonPtNoDxyCutME_, muonPtVsLS_, extraflags_cff::muons, muonSelectionDxy_, muonSelectionGeneral_, muonSelectionPt_, muonToken_, nmuons_, num_genTriggerEventFlag_, DiDispStaMuonMonitor::DiDispStaMuonME::numerator, phi, EnergyCorrector::pt, reco::TrackBase::pt(), subMuonDxyME_, subMuonEtaME_, subMuonPhiME_, subMuonPtME_, and subMuonPtME_variableBinning_.

                                                                                        {
 
   // Filter out events if Trigger Filtering is requested
   if (den_genTriggerEventFlag_->on() && ! den_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
 
   int ls = iEvent.id().luminosityBlock();
 
   edm::Handle<reco::TrackCollection> DSAHandle;
   iEvent.getByToken( muonToken_, DSAHandle );
   if ((unsigned int)(DSAHandle->size()) < nmuons_ ) return;
   std::vector<edm::Ptr<reco::Track>> dsaMuonPtrs_{};// = DSAHandle->ptrs();
   for (size_t i(0); i!=DSAHandle->size(); ++i) {
     dsaMuonPtrs_.emplace_back(DSAHandle, i);
   }
   std::vector<edm::Ptr<reco::Track>> muons{}, muonsCutOnPt{}, muonsCutOnDxy{}, muonsCutOnPtAndDxy{};
  
   // general selection
   auto selectGeneral_([this](edm::Ptr<reco::Track> const& m)->bool {return muonSelectionGeneral_(*m);});
   std::copy_if(dsaMuonPtrs_.begin(), dsaMuonPtrs_.end(), back_inserter(muons), selectGeneral_);
   if ((unsigned int)(muons.size()) < nmuons_ ) return;
 
   // sort by pt
   auto ptSorter_ = [](edm::Ptr<reco::Track> const& lhs, edm::Ptr<reco::Track> const& rhs)->bool {return lhs->pt() > rhs->pt();};
   std::sort(muons.begin(), muons.end(), ptSorter_);
 
   // cut on pt
   auto selectOnPt_([this](edm::Ptr<reco::Track> const& m)->bool {return muonSelectionPt_(*m);});
   std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPt), selectOnPt_);
   // cut on dxy
   auto selectOnDxy_([this](edm::Ptr<reco::Track> const& m)->bool {return muonSelectionDxy_(*m);});
   std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnDxy), selectOnDxy_);
   // cut on pt and dxy
   auto selectOnPtAndDxy_([this](edm::Ptr<reco::Track> const& m)->bool {return muonSelectionPt_(*m) && muonSelectionDxy_(*m);});
   std::copy_if(muons.begin(), muons.end(), back_inserter(muonsCutOnPtAndDxy), selectOnPtAndDxy_);
 
   std::sort(muonsCutOnPt.begin(), muonsCutOnPt.end(), ptSorter_);
   std::sort(muonsCutOnDxy.begin(), muonsCutOnDxy.end(), ptSorter_);
   std::sort(muonsCutOnPtAndDxy.begin(), muonsCutOnPtAndDxy.end(), ptSorter_);
 
   // --------------------------------
   // filling histograms (denominator)
   // --------------------------------
   if(muonsCutOnDxy.size() >= nmuons_) {
       // pt has cut on dxy
       muonPtME_.denominator->Fill( muonsCutOnDxy[0]->pt() );
       muonPtNoDxyCutME_.denominator->Fill( muons[0]->pt() );
       muonPtME_variableBinning_.denominator->Fill( muonsCutOnDxy[0]->pt() );
       muonPtVsLS_.denominator->Fill( ls, muonsCutOnDxy[0]->pt() );
       if(nmuons_ > 1) {
         subMuonPtME_.denominator->Fill( muonsCutOnDxy[1]->pt() );
         subMuonPtME_variableBinning_.denominator->Fill( muonsCutOnDxy[1]->pt() );
       }
   }
   if(muonsCutOnPtAndDxy.size() >= nmuons_) {
       // eta, phi have cut on pt and dxy
       muonEtaME_.denominator->Fill( muonsCutOnPtAndDxy[0]->eta() );
       muonPhiME_.denominator->Fill( muonsCutOnPtAndDxy[0]->phi() );
       if(nmuons_ > 1) {
           subMuonEtaME_.denominator->Fill( muonsCutOnPtAndDxy[1]->eta() );
           subMuonPhiME_.denominator->Fill( muonsCutOnPtAndDxy[1]->phi() );
       }
   }
   if(muonsCutOnPt.size() >= nmuons_){
       // dxy has cut on pt
       muonDxyME_.denominator->Fill( muonsCutOnPt[0]->dxy() );
       if (nmuons_ > 1) {
         subMuonDxyME_.denominator->Fill( muonsCutOnPt[1]->dxy() );
       }
   }
 
 
   // --------------------------------
   // filling histograms (numerator)
   // --------------------------------
   if (num_genTriggerEventFlag_->on() && ! num_genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
   
   if(muonsCutOnDxy.size() >= nmuons_) {
       // pt has cut on dxy
       muonPtME_.numerator->Fill( muonsCutOnDxy[0]->pt() );
       muonPtNoDxyCutME_.numerator->Fill( muons[0]->pt() );
       muonPtME_variableBinning_.numerator->Fill( muonsCutOnDxy[0]->pt() );
       muonPtVsLS_.numerator->Fill( ls, muonsCutOnDxy[0]->pt() );
       if(nmuons_ > 1) {
         subMuonPtME_.numerator->Fill( muonsCutOnDxy[1]->pt() );
         subMuonPtME_variableBinning_.numerator->Fill( muonsCutOnDxy[1]->pt() );
       }
   }
   if(muonsCutOnPtAndDxy.size() >= nmuons_) {
       // eta, phi have cut on pt and dxy
       muonEtaME_.numerator->Fill( muonsCutOnPtAndDxy[0]->eta() );
       muonPhiME_.numerator->Fill( muonsCutOnPtAndDxy[0]->phi() );
       if(nmuons_ > 1) {
           subMuonEtaME_.numerator->Fill( muonsCutOnPtAndDxy[1]->eta() );
           subMuonPhiME_.numerator->Fill( muonsCutOnPtAndDxy[1]->phi() );
       }
   }
   if(muonsCutOnPt.size() >= nmuons_){
       // dxy has cut on pt
       muonDxyME_.numerator->Fill( muonsCutOnPt[0]->dxy() );
       if (nmuons_ > 1) {
         subMuonDxyME_.numerator->Fill( muonsCutOnPt[1]->dxy() );
       }
   }
 
 
 }

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

overrideprotected

Definition at line 121 of file DiDispStaMuonMonitor.cc.

References bookME(), den_genTriggerEventFlag_, folderName_, ls_binning_, muonDxy_binning_, muonDxyME_, muonEta_binning_, muonEtaME_, muonPhi_binning_, muonPhiME_, muonPt_binning_, muonPt_variable_binning_, muonPtME_, muonPtME_variableBinning_, muonPtNoDxyCutME_, muonPtVsLS_, DiDispStaMuonMonitor::MEbinning::nbins, nmuons_, num_genTriggerEventFlag_, DQMStore::IBooker::setCurrentFolder(), setTitle(), AlCaHLTBitMon_QueryRunRegistry::string, subMuonDxyME_, subMuonEtaME_, subMuonPhiME_, subMuonPtME_, subMuonPtME_variableBinning_, DiDispStaMuonMonitor::MEbinning::xmax, and DiDispStaMuonMonitor::MEbinning::xmin.

 {
 
   std::string histname, histtitle;
   bool bookDen;
 
   std::string currentFolder = folderName_ ;
   ibooker.setCurrentFolder(currentFolder);
 
   histname = "muonPt"; histtitle = "muonPt";
   bookDen = true;
   bookME(ibooker,muonPtME_,histname,histtitle,muonPt_binning_.nbins,muonPt_binning_.xmin, muonPt_binning_.xmax);
   setTitle(muonPtME_,"DisplacedStandAlone Muon p_{T} [GeV]","Events / [GeV]", bookDen);
 
   histname = "muonPtNoDxyCut"; histtitle = "muonPtNoDxyCut";
   bookDen = true;
   bookME(ibooker,muonPtNoDxyCutME_,histname,histtitle,muonPt_binning_.nbins,muonPt_binning_.xmin, muonPt_binning_.xmax);
   setTitle(muonPtNoDxyCutME_,"DisplacedStandAlone Muon p_{T} [GeV] without Dxy cut","Events / [GeV]", bookDen);
 
   histname = "muonPt_variable"; histtitle = "muonPt";
   bookDen = true;
   bookME(ibooker,muonPtME_variableBinning_,histname,histtitle,muonPt_variable_binning_);
   setTitle(muonPtME_variableBinning_,"DisplacedStandAlone Muon p_{T} [GeV]","Events / [GeV]", bookDen);
 
   histname = "muonPtVsLS"; histtitle = "muonPt vs LS";
   bookDen = true;
   bookME(ibooker,muonPtVsLS_,histname,histtitle,ls_binning_.nbins, ls_binning_.xmin, ls_binning_.xmax,muonPt_binning_.xmin, muonPt_binning_.xmax, bookDen);
   setTitle(muonPtVsLS_,"LS","DisplacedStandAlone Muon p_{T} [GeV]", bookDen);
 
   histname = "muonEta"; histtitle = "muonEta";
   bookDen = true;
   bookME(ibooker,muonEtaME_,histname,histtitle,muonEta_binning_.nbins,muonEta_binning_.xmin, muonEta_binning_.xmax);
   setTitle(muonEtaME_,"DisplacedStandAlone Muon #eta","Events", bookDen);
 
   histname = "muonPhi"; histtitle = "muonPhi";
   bookDen = true;
   bookME(ibooker,muonPhiME_,histname,histtitle,muonPhi_binning_.nbins,muonPhi_binning_.xmin, muonPhi_binning_.xmax);
   setTitle(muonPhiME_,"DisplacedStandAlone Muon #phi","Events", bookDen);
 
   histname = "muonDxy"; histtitle = "muonDxy";
   bookDen = true;
   bookME(ibooker,muonDxyME_,histname,histtitle,muonDxy_binning_.nbins,muonDxy_binning_.xmin, muonDxy_binning_.xmax);
   setTitle(muonDxyME_,"DisplacedStandAlone Muon #dxy","Events", bookDen);
 
 
   //-----------------------
   //                      |
   //-----------------------
 
   if (nmuons_>1) {
     histname = "subMuonPt"; histtitle = "subMuonPt";
     bookDen = true;
     bookME(ibooker,subMuonPtME_,histname,histtitle,muonPt_binning_.nbins,muonPt_binning_.xmin, muonPt_binning_.xmax);
     setTitle(subMuonPtME_,"Subleading DisplacedStandAlone Muon p_{T} [GeV]","Events / [GeV]", bookDen);
 
     histname = "subMuonPt_variable"; histtitle = "subMuonPt";
     bookDen = true;
     bookME(ibooker,subMuonPtME_variableBinning_,histname,histtitle,muonPt_variable_binning_);
     setTitle(subMuonPtME_variableBinning_,"Subleading DisplacedStandAlone Muon p_{T} [GeV]","Events / [GeV]", bookDen);
 
     histname = "subMuonEta"; histtitle = "subMuonEta";
     bookDen = true;
     bookME(ibooker,subMuonEtaME_,histname,histtitle,muonEta_binning_.nbins,muonEta_binning_.xmin, muonEta_binning_.xmax);
     setTitle(subMuonEtaME_,"Subleading DisplacedStandAlone Muon #eta","Events", bookDen);
 
     histname = "subMuonPhi"; histtitle = "subMuonPhi";
     bookDen = true;
     bookME(ibooker,subMuonPhiME_,histname,histtitle,muonPhi_binning_.nbins,muonPhi_binning_.xmin, muonPhi_binning_.xmax);
     setTitle(subMuonPhiME_,"Subleading DisplacedStandAlone Muon #phi","Events", bookDen);
 
     histname = "subMuonDxy"; histtitle = "subMuonDxy";
     bookDen = true;
     bookME(ibooker,subMuonDxyME_,histname,histtitle,muonDxy_binning_.nbins,muonDxy_binning_.xmin, muonDxy_binning_.xmax);
     setTitle(subMuonDxyME_,"Subleading DisplacedStandAlone Muon #dxy","Events", 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 DiDispStaMuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		DiDispStaMuonME &	me,
		const std::string &	histname,
		const std::string &	histtitle,
		int	nbins,
		double	xmin,
		double	xmax
	)

protected

Definition at line 85 of file DiDispStaMuonMonitor.cc.

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

protected

Definition at line 90 of file DiDispStaMuonMonitor.cc.

References DQMStore::IBooker::book1D(), DiDispStaMuonMonitor::DiDispStaMuonME::denominator, pileupCalc::nbins, and DiDispStaMuonMonitor::DiDispStaMuonME::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 DiDispStaMuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		DiDispStaMuonME &	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 98 of file DiDispStaMuonMonitor.cc.

References DQMStore::IBooker::bookProfile(), DiDispStaMuonMonitor::DiDispStaMuonME::denominator, and DiDispStaMuonMonitor::DiDispStaMuonME::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 DiDispStaMuonMonitor::bookME	(	DQMStore::IBooker &	ibooker,
		DiDispStaMuonME &	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 103 of file DiDispStaMuonMonitor.cc.

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

protected

Definition at line 108 of file DiDispStaMuonMonitor.cc.

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

static

Definition at line 326 of file DiDispStaMuonMonitor.cc.

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

 {
   edm::ParameterSetDescription desc;
   desc.add<std::string>  ( "FolderName", "HLT/EXO/DiDispStaMuon" );
 
   desc.add<edm::InputTag>( "muons",    edm::InputTag("displacedStandAloneMuons") );
   desc.add<unsigned int>("nmuons",     2);
 
   edm::ParameterSetDescription muonSelection;
   muonSelection.add<std::string>("general", "pt > 0");
   muonSelection.add<std::string>("pt", "");
   muonSelection.add<std::string>("dxy", "pt > 0");
   desc.add<edm::ParameterSetDescription>("muonSelection", muonSelection);
 
   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 muonPtPSet;
   edm::ParameterSetDescription muonEtaPSet;
   edm::ParameterSetDescription muonPhiPSet;
   edm::ParameterSetDescription muonDxyPSet;
   edm::ParameterSetDescription lsPSet;
   fillHistoPSetDescription(muonPtPSet);
   fillHistoPSetDescription(muonEtaPSet);
   fillHistoPSetDescription(muonPhiPSet);
   fillHistoPSetDescription(muonDxyPSet);
   fillHistoPSetDescription(lsPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonPtPSet", muonPtPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonEtaPSet", muonEtaPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonPhiPSet", muonPhiPSet);
   histoPSet.add<edm::ParameterSetDescription>("muonDxyPSet", muonDxyPSet);
   histoPSet.add<edm::ParameterSetDescription>("lsPSet", lsPSet);
   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> >("muonPtBinning", bins);
 
   desc.add<edm::ParameterSetDescription>("histoPSet",histoPSet);
 
   descriptions.add("DiDispStaMuonMonitoring", desc);
 }

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

static

Definition at line 321 of file DiDispStaMuonMonitor.cc.

References edm::ParameterSetDescription::add().

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

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

static

Definition at line 314 of file DiDispStaMuonMonitor.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 );
 }

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

staticprivate

Definition at line 65 of file DiDispStaMuonMonitor.cc.

References edm::ParameterSet::getParameter().

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

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

staticprivate

Definition at line 56 of file DiDispStaMuonMonitor.cc.

References edm::ParameterSet::getParameter().

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

void DiDispStaMuonMonitor::setTitle	(	DiDispStaMuonME &	me,
		const std::string &	titleX,
		const std::string &	titleY,
		bool	bookDen
	)

protected

Definition at line 74 of file DiDispStaMuonMonitor.cc.

References DiDispStaMuonMonitor::DiDispStaMuonME::denominator, DiDispStaMuonMonitor::DiDispStaMuonME::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);
   if(bookDen) {
     me.denominator->setAxisTitle(titleX,1);
     me.denominator->setAxisTitle(titleY,2);
   }
 
 }