#include <HLTScalers.h>

Inheritance diagram for HLTScalers:

Public Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override

void	beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c) override

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

void	dqmBeginRun (const edm::Run &run, const edm::EventSetup &c) override

void	endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c) override
	DQM Client Diagnostic should be performed here: More...

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

	HLTScalers (const edm::ParameterSet &ps)

	~HLTScalers () override=default

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

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

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

	~DQMEDAnalyzer () override=default

Private Attributes
int	currentRun_

MonitorElement *	detailedScalers_

MonitorElement *	diagnostic_

std::string	folderName_

MonitorElement *	hltBx_

MonitorElement *	hltBxVsPath_

HLTConfigProvider	hltConfig_

MonitorElement *	hltCorrelations_

MonitorElement *	hltOverallScaler_

MonitorElement *	hltOverallScalerN_

bool	monitorDaemon_

int	nev_

int	nLumi_

MonitorElement *	nLumiBlock_

MonitorElement *	nProc_

std::vector< std::pair< std::string, std::vector< std::string > > >	pairPDPaths_

std::string	processname_

bool	resetMe_

MonitorElement *	scalers_

MonitorElement *	scalersException_

MonitorElement *	scalersN_

MonitorElement *	scalersPD_

bool	sentPaths_

edm::EDGetTokenT< edm::TriggerResults >	trigResultsSource_

Detailed Description

Definition at line 66 of file HLTScalers.h.

Constructor & Destructor Documentation

HLTScalers::HLTScalers ( const edm::ParameterSet & ps )

Definition at line 79 of file HLTScalers.cc.

References LogDebug.

     : folderName_(ps.getUntrackedParameter<std::string>("dqmFolder",
                                                         "HLT/HLTScalers_EvF")),
       processname_(ps.getParameter<std::string>("processname")),
       pairPDPaths_(),
       trigResultsSource_(consumes<TriggerResults>(
           ps.getParameter<edm::InputTag>("triggerResults"))),
       scalersN_(nullptr),
       scalersException_(nullptr),
       hltCorrelations_(nullptr),
       detailedScalers_(nullptr),
       nProc_(nullptr),
       nLumiBlock_(nullptr),
       hltBx_(nullptr),
       hltBxVsPath_(nullptr),
       hltOverallScaler_(nullptr),
       hltOverallScalerN_(nullptr),
       diagnostic_(nullptr),
       sentPaths_(false),
       monitorDaemon_(ps.getUntrackedParameter<bool>("MonitorDaemon", false)),
       nev_(0),
       nLumi_(0) {
   LogDebug("HLTScalers") << "HLTScalers: constructor....";
 }

HLTScalers::~HLTScalers ( )

overridedefault

Member Function Documentation

void HLTScalers::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 194 of file HLTScalers.cc.

References accept(), edm::HLTGlobalStatus::accept(), b, edm::EventBase::bunchCrossing(), detailedScalers_, diagnostic_, Exception, MonitorElement::Fill(), plotBeamSpotDB::first, edm::Event::getByToken(), MonitorElement::getTH1(), hltBx_, hltBxVsPath_, hltCorrelations_, hltOverallScaler_, hltOverallScalerN_, SelectingProcedure_cff::hltResults, mps_fire::i, edm::HLTGlobalStatus::index(), checklumidiff::l, LogDebug, names, nev_, nProc_, pairPDPaths_, Pass, lumiQueryAPI::q, scalers_, scalersException_, scalersN_, scalersPD_, edm::second(), sentPaths_, MonitorElement::setBinContent(), edm::HLTGlobalStatus::size(), edm::HLTGlobalStatus::state(), AlCaHLTBitMon_QueryRunRegistry::string, edm::TriggerNames::triggerIndex(), edm::TriggerNames::triggerNames(), edm::Event::triggerNames(), trigNames, and trigResultsSource_.

                                                                   {
   nProc_->Fill(++nev_);
   diagnostic_->setBinContent(1, 1);  // this ME is never touched -
   // it just tells you how the merging is doing.
 
   edm::Handle<TriggerResults> hltResults;
   bool b = e.getByToken(trigResultsSource_, hltResults);
   if ( !b ) {
     Labels l;
     labelsForToken(trigResultsSource_, l);
 
     edm::LogInfo("HLTScalers") << "getByLabel for TriggerResults failed"
                                << " with label " << l.module;
     return;
   }
   int npath = hltResults->size();
   unsigned int nPD = pairPDPaths_.size();
 
   const edm::TriggerNames& trigNames = e.triggerNames(*hltResults);
   // for some reason this doesn't appear to work on the first event sometimes
   if (!sentPaths_) {
     const edm::TriggerNames& names = e.triggerNames(*hltResults);
 
     // save path names in DQM-accessible format
     int q = 0;
     for (TriggerNames::Strings::const_iterator j = names.triggerNames().begin();
          j != names.triggerNames().end(); ++j) {
       LogDebug("HLTScalers") << q << ": " << *j;
       ++q;
       scalers_->getTH1()->GetXaxis()->SetBinLabel(q, j->c_str());
     }
 
     for (unsigned int i = 0; i < nPD; i++) {
       LogDebug("HLTScalers") << i << ": " << pairPDPaths_[i].first << std::endl;
       scalersPD_->getTH1()->GetXaxis()->SetBinLabel(
           i + 1, pairPDPaths_[i].first.c_str());
     }
 
     sentPaths_ = true;
   }
 
   bool accept = false;
   int bx = e.bunchCrossing();
   for (int i = 0; i < npath; ++i) {
     // state returns 0 on ready, 1 on accept, 2 on fail, 3 on exception.
     // these are defined in HLTEnums.h
     for (unsigned int j = 0; j < hltResults->index(i); ++j) {
       detailedScalers_->Fill(i, j);
     }
     if (hltResults->state(i) == hlt::Pass) {
       scalers_->Fill(i);
       scalersN_->Fill(i);
       hltBxVsPath_->Fill(bx, i);
       accept = true;
       for (int j = i + 1; j < npath; ++j) {
         if (hltResults->state(j) == hlt::Pass) {
           hltCorrelations_->Fill(i, j);  // fill
           hltCorrelations_->Fill(j, i);
         }
       }
     } else if (hltResults->state(i) == hlt::Exception) {
       scalersException_->Fill(i);
     }
   }
   if (accept) {
     hltOverallScaler_->Fill(1.0);
     hltOverallScalerN_->Fill(1.0);
     hltBx_->Fill(int(bx));
   }
 
   bool anyGroupPassed = false;
   for (unsigned int mi = 0; mi < pairPDPaths_.size(); mi++) {
     bool groupPassed = false;
 
     for (unsigned int i = 0; i < pairPDPaths_[mi].second.size(); i++) {
       // string hltPathName =  hist_2d->GetXaxis()->GetBinLabel(i);
       std::string hltPathName = pairPDPaths_[mi].second[i];
 
       // check if this is hlt path name
       // unsigned int pathByIndex = triggerNames.triggerIndex(hltPathName);
       unsigned int pathByIndex =
           trigNames.triggerIndex(pairPDPaths_[mi].second[i]);
       if (pathByIndex >= hltResults->size()) continue;
 
       // check if its L1 passed
       // comment out below but set groupL1Passed to true always
       // if(hasL1Passed(hltPathName,triggerNames)) groupL1Passed = true;
       // groupL1Passed = true;
 
       // Fill HLTPassed Matrix and HLTPassFail Matrix
       // --------------------------------------------------------
 
       if (hltResults->accept(pathByIndex)) {
         groupPassed = true;
         break;
       }
     }
 
     if (groupPassed) {
       scalersPD_->Fill(mi);
       anyGroupPassed = true;
     }
   }
 
   if (anyGroupPassed) scalersPD_->Fill(pairPDPaths_.size() - 1);
 }

void HLTScalers::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

override

Definition at line 186 of file HLTScalers.cc.

References hltOverallScalerN_, LogDebug, MonitorElement::Reset(), and scalersN_.

                                                               {
   LogDebug("HLTScalers") << "Start of luminosity block.";
   // reset the N guys
   if (scalersN_) scalersN_->Reset();
   if (hltOverallScalerN_) hltOverallScalerN_->Reset();
 }

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

override

Definition at line 140 of file HLTScalers.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookInt(), detailedScalers_, diagnostic_, folderName_, hltBx_, hltBxVsPath_, hltConfig_, hltCorrelations_, hltOverallScaler_, hltOverallScalerN_, nLumiBlock_, nProc_, pairPDPaths_, scalers_, scalersException_, scalersN_, scalersPD_, DQMStore::IBooker::setCurrentFolder(), HLTConfigProvider::size(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                       {
   std::string rawdir(folderName_ + "/raw");
   iBooker.setCurrentFolder(rawdir);
 
   nProc_ = iBooker.bookInt("nProcessed");
   nLumiBlock_ = iBooker.bookInt("nLumiBlock");
   diagnostic_ = iBooker.book1D("hltMerge", "HLT merging diagnostic", 1, 0.5, 1.5);
   // fill for ever accepted event
   hltOverallScaler_ =
       iBooker.book1D("hltOverallScaler", "HLT Overall Scaler", 1, 0.5, 1.5);
   hltOverallScalerN_ = iBooker.book1D("hltOverallScalerN",
                                     "Reset HLT Overall Scaler", 1, 0.5, 1.5);
 
   // DQM: Previously the number of trigger paths was determined on the first
   // event, by taking the size of the htlResults to book the histogram.
   // Now we use the size of the hltConfig instead.
   int npath = hltConfig_.size();
   unsigned int nPD = pairPDPaths_.size();
 
   // need to get maxModules dynamically
   int maxModules = 200;
 
   scalersPD_ = iBooker.book1D("pdScalers", "PD scalers (stream A)", nPD, -0.5,
                             nPD - 0.5);
   detailedScalers_ =
       iBooker.book2D("detailedHltScalers", "HLT Scalers", npath, -0.5,
                    npath - 0.5, maxModules, 0, maxModules - 1);
   scalers_ =
       iBooker.book1D("hltScalers", "HLT scalers", npath, -0.5, npath - 0.5);
   scalersN_ = iBooker.book1D("hltScalersN", "Reset HLT scalers", npath, -0.5,
                            npath - 0.5);
   scalersException_ = iBooker.book1D("hltExceptions", "HLT Exception scalers",
                                    npath, -0.5, npath - 0.5);
   hltCorrelations_ =
       iBooker.book2D("hltCorrelations", "HLT Scalers", npath, -0.5, npath - 0.5,
                    npath, -0.5, npath - 0.5);
 
   // these two belong in top-level
   iBooker.setCurrentFolder(folderName_);
   hltBxVsPath_ = iBooker.book2D("hltBxVsPath", "HLT Accept vs Bunch Number",
                               3600, -0.5, 3599.5, npath, -0.5, npath - 0.5);
   hltBx_ =
       iBooker.book1D("hltBx", "Bx of HLT Accepted Events ", 3600, -0.5, 3599.5);
 }

void HLTScalers::dqmBeginRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

override

Definition at line 104 of file HLTScalers.cc.

References HLTConfigProvider::datasetContent(), hltConfig_, mps_fire::i, edm::RunBase::id(), HLTConfigProvider::init(), LogDebug, pairPDPaths_, processname_, HLTConfigProvider::streamContent(), HLTConfigProvider::streamIndex(), and HLTConfigProvider::streamNames().

                                                                       {
   LogDebug("HLTScalers") << "HLTScalers::beginRun, run " << run.id();
 
   // HLT config does not change within runs!
   bool changed = false;
 
   // clear vector pairPDPaths_
   pairPDPaths_.clear();
 
   if (not hltConfig_.init(run, c, processname_, changed)) {
     edm::LogError("TrigXMonitor") << "HLTConfigProvider failed to initialize.";
   } else {
     // check if trigger name in (new) config
     //  cout << "Available TriggerNames are: " << endl;
     //  hltConfig_.dump("Triggers");
 
     if (hltConfig_.streamIndex("A") < hltConfig_.streamNames().size()) {
       // get hold of PD names and constituent path names
       const std::vector<std::string>& PD = hltConfig_.streamContent("A");
 
       for (unsigned int i = 0; i < PD.size(); i++) {
         const std::vector<std::string>& datasetPaths =
             hltConfig_.datasetContent(PD[i]);
         pairPDPaths_.push_back(make_pair(PD[i], datasetPaths));
       }
 
       // push stream A and its PDs
       pairPDPaths_.push_back(make_pair("A", PD));
 
     } else {
       LogDebug("HLTScalers")
           << "HLTScalers::beginRun, steamm A not in the HLT menu ";
     }
   }
 }

void HLTScalers::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

override

DQM Client Diagnostic should be performed here:

Definition at line 302 of file HLTScalers.cc.

References MonitorElement::Fill(), edm::LuminosityBlockBase::id(), LogDebug, edm::LuminosityBlockID::luminosityBlock(), and nLumiBlock_.

                                                             {
   // put this in as a first-pass for figuring out the rate
   // each lumi block is 23 seconds in length
   nLumiBlock_->Fill(lumiSeg.id().luminosityBlock());
 
   LogDebug("HLTScalers") << "End of luminosity block.";
 }

void HLTScalers::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

override

Definition at line 311 of file HLTScalers.cc.

References edm::RunBase::id(), and LogDebug.

                                                                  {
   LogDebug("HLTScalers") << "HLTScalers::endRun , run " << run.id();
 }

Member Data Documentation

int HLTScalers::currentRun_

private

Definition at line 106 of file HLTScalers.h.

MonitorElement* HLTScalers::detailedScalers_

private

Definition at line 94 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* HLTScalers::diagnostic_

private

Definition at line 100 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

std::string HLTScalers::folderName_

private

Definition at line 84 of file HLTScalers.h.

Referenced by bookHistograms().

MonitorElement* HLTScalers::hltBx_

private

Definition at line 97 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement * HLTScalers::hltBxVsPath_

private

Definition at line 97 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

HLTConfigProvider HLTScalers::hltConfig_

private

Definition at line 83 of file HLTScalers.h.

Referenced by bookHistograms(), and dqmBeginRun().

MonitorElement* HLTScalers::hltCorrelations_

private

Definition at line 93 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* HLTScalers::hltOverallScaler_

private

Definition at line 98 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* HLTScalers::hltOverallScalerN_

private

Definition at line 99 of file HLTScalers.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

bool HLTScalers::monitorDaemon_

private

Definition at line 102 of file HLTScalers.h.

int HLTScalers::nev_

private

Definition at line 104 of file HLTScalers.h.

Referenced by analyze().

int HLTScalers::nLumi_

private

Definition at line 105 of file HLTScalers.h.

MonitorElement* HLTScalers::nLumiBlock_

private

Definition at line 96 of file HLTScalers.h.

Referenced by bookHistograms(), and endLuminosityBlock().

MonitorElement* HLTScalers::nProc_

private

Definition at line 95 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

std::vector<std::pair<std::string, std::vector<std::string> > > HLTScalers::pairPDPaths_

private

Definition at line 86 of file HLTScalers.h.

Referenced by analyze(), bookHistograms(), and dqmBeginRun().

std::string HLTScalers::processname_

private

Definition at line 85 of file HLTScalers.h.

Referenced by dqmBeginRun().

bool HLTScalers::resetMe_

private

Definition at line 102 of file HLTScalers.h.

MonitorElement* HLTScalers::scalers_

private

Definition at line 90 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* HLTScalers::scalersException_

private

Definition at line 92 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* HLTScalers::scalersN_

private

Definition at line 91 of file HLTScalers.h.

Referenced by analyze(), beginLuminosityBlock(), and bookHistograms().

MonitorElement* HLTScalers::scalersPD_

private

Definition at line 89 of file HLTScalers.h.

Referenced by analyze(), and bookHistograms().

bool HLTScalers::sentPaths_

private

Definition at line 102 of file HLTScalers.h.

Referenced by analyze().

edm::EDGetTokenT<edm::TriggerResults> HLTScalers::trigResultsSource_

private

Definition at line 87 of file HLTScalers.h.

Referenced by analyze().

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation