Inheritance diagram for TriggerRatesMonitor:

Classes
struct	HLTIndices

struct	HLTRatesPlots

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

	~TriggerRatesMonitor ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
virtual void	analyze (edm::Event const &, edm::EventSetup const &) override

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

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

Private Attributes
std::vector< TH1F * >	m_dataset_counts

std::vector< std::vector < unsigned int > >	m_datasets

std::string	m_dqm_path

TH1F *	m_events_calibration

TH1F *	m_events_physics

TH1F *	m_events_processed

TH1F *	m_events_random

std::vector< HLTRatesPlots >	m_hlt_counts

edm::EDGetTokenT < edm::TriggerResults >	m_hlt_results

HLTConfigProvider	m_hltConfig

std::vector< HLTIndices >	m_hltIndices

std::vector< TH1F * >	m_l1t_algo_counts

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	m_l1t_results

std::vector< TH1F * >	m_l1t_tech_counts

L1GtTriggerMask const *	m_l1tAlgoMask

L1GtTriggerMenu const *	m_l1tMenu

L1GtTriggerMask const *	m_l1tTechMask

uint32_t	m_lumisections_range

std::vector< TH1F * >	m_stream_counts

std::vector< std::vector < unsigned int > >	m_streams

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Protected Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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)

Detailed Description

Definition at line 66 of file TriggerRatesMonitor.cc.

Constructor & Destructor Documentation

TriggerRatesMonitor::TriggerRatesMonitor ( edm::ParameterSet const & config )

explicit

Definition at line 148 of file TriggerRatesMonitor.cc.

                                                                        :
   // module configuration
   m_l1t_results( consumes<L1GlobalTriggerReadoutRecord>( config.getUntrackedParameter<edm::InputTag>( "l1tResults" ) ) ),
   m_hlt_results( consumes<edm::TriggerResults>(          config.getUntrackedParameter<edm::InputTag>( "hltResults" ) ) ),
   m_dqm_path(                                            config.getUntrackedParameter<std::string>(   "dqmPath" ) ),
   m_lumisections_range(                                  config.getUntrackedParameter<uint32_t>(      "lumisectionRange" ) ),
   // L1T and HLT configuration
   m_l1tMenu( nullptr ),
   m_l1tAlgoMask( nullptr ),
   m_l1tTechMask( nullptr),
   m_hltConfig(),
   m_hltIndices(),
   m_datasets(),
   m_streams(),
   // overall event count and event types
   m_events_processed( nullptr ),
   m_events_physics( nullptr ),
   m_events_calibration( nullptr ),
   m_events_random( nullptr ),
   // L1T triggers
   m_l1t_algo_counts(),
   m_l1t_tech_counts(),
   // HLT triggers
   m_hlt_counts(),
   // datasets
   m_dataset_counts(),
   // streams
   m_stream_counts()
 {
 }

TriggerRatesMonitor::~TriggerRatesMonitor ( )

Definition at line 179 of file TriggerRatesMonitor.cc.

180 {

181 }

Member Function Documentation

void TriggerRatesMonitor::analyze	(	edm::Event const &	event,
		edm::EventSetup const &	setup
	)

overrideprivatevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 349 of file TriggerRatesMonitor.cc.

References accept(), edm::HLTPathStatus::accept(), edm::HLTGlobalStatus::at(), edm::EventAuxiliary::CalibrationTrigger, L1GlobalTriggerReadoutRecord::decisionWord(), relativeConstraints::error, edm::HLTPathStatus::error(), edm::EventAuxiliary::ErrorTrigger, event(), edm::EventBase::experimentType(), HcalObjRepresent::Fill(), JetPDSkim_cfg::hltResults, i, edm::HLTPathStatus::index(), HLTConfigProvider::inited(), j, JetPDSkim_cfg::l1tResults, m_dataset_counts, m_datasets, m_events_calibration, m_events_physics, m_events_processed, m_events_random, m_hlt_counts, m_hlt_results, m_hltConfig, m_hltIndices, m_l1t_algo_counts, m_l1t_results, m_l1t_tech_counts, m_l1tAlgoMask, m_l1tMenu, m_l1tTechMask, m_stream_counts, m_streams, cmsHarvester::path, edm::EventAuxiliary::PhysicsTrigger, edm::EventAuxiliary::RandomTrigger, edm::EventAuxiliary::Reserved, edm::HLTGlobalStatus::size(), L1GlobalTriggerReadoutRecord::technicalTriggerWord(), edm::EventAuxiliary::TestTrigger, edm::EventAuxiliary::TracedEvent, edm::EventAuxiliary::Undefined, and edm::HLTPathStatus::wasrun().

 {
   unsigned int lumisection = event.luminosityBlock();
 
   // book the overall event count and event types rates
   m_events_processed->Fill(lumisection);
   switch (event.experimentType()) {
     case edm::EventAuxiliary::PhysicsTrigger :
       m_events_physics->Fill(lumisection);
       break;
     case edm::EventAuxiliary::CalibrationTrigger :
       m_events_calibration->Fill(lumisection);
       break;
     case edm::EventAuxiliary::RandomTrigger :
       m_events_random->Fill(lumisection);
       break;
     case edm::EventAuxiliary::Undefined :
     case edm::EventAuxiliary::Reserved :
     case edm::EventAuxiliary::TracedEvent :
     case edm::EventAuxiliary::TestTrigger :
     case edm::EventAuxiliary::ErrorTrigger :
       // ignore these event types
       break;
   }
 
   // monitor the L1 triggers rates
   if (m_l1tMenu and m_l1tAlgoMask and m_l1tTechMask) {
     L1GlobalTriggerReadoutRecord const & l1tResults = * get<L1GlobalTriggerReadoutRecord>(event, m_l1t_results);
 
     const std::vector<bool> & algoword = l1tResults.decisionWord();
     if (algoword.size() == m_l1t_algo_counts.size()) {
       for (unsigned int i = 0; i < m_l1t_algo_counts.size(); ++i)
         if (algoword[i])
           m_l1t_algo_counts[i]->Fill(lumisection);
     } else {
       edm::LogWarning("TriggerRatesMonitor") << "This should never happen: the size of the L1 Algo Trigger mask does not match the number of L1 Algo Triggers";
     }
 
     const std::vector<bool> & techword = l1tResults.technicalTriggerWord();
     if (techword.size() == m_l1t_tech_counts.size()) {
       for (unsigned int i = 0; i < m_l1t_tech_counts.size(); ++i)
         if (techword[i])
           m_l1t_tech_counts[i]->Fill(lumisection);
     } else {
       edm::LogWarning("TriggerRatesMonitor") << "This should never happen: the size of the L1 Tech Trigger mask does not match the number of L1 Tech Triggers";
     }
   }
 
   // monitor the HLT triggers and datsets rates
   if (m_hltConfig.inited()) {
     edm::TriggerResults const & hltResults = * get<edm::TriggerResults>(event, m_hlt_results);
     if (hltResults.size() == m_hlt_counts.size()) {
       for (unsigned int i = 0; i < m_hlt_counts.size(); ++i) {
         edm::HLTPathStatus const & path = hltResults.at(i);
         if (path.wasrun())
           m_hlt_counts[i].wasrun->Fill(lumisection);
         if (path.index() > m_hltIndices[i].index_l1_seed)
           m_hlt_counts[i].pass_l1_seed->Fill(lumisection);
         if  (path.index() > m_hltIndices[i].index_prescale)
           m_hlt_counts[i].pass_prescale->Fill(lumisection);
         if (path.accept())
           m_hlt_counts[i].accept->Fill(lumisection);
         else if (path.error())
           m_hlt_counts[i].error ->Fill(lumisection);
         else
           m_hlt_counts[i].reject->Fill(lumisection);
       }
     } else {
       edm::LogWarning("TriggerRatesMonitor") << "This should never happen: the number of HLT paths has changed since the beginning of the run";
     }
 
     for (unsigned int i = 0; i < m_datasets.size(); ++i)
       for (unsigned int j: m_datasets[i])
         if (hltResults.at(j).accept()) {
           m_dataset_counts[i]->Fill(lumisection);
           // ensure each dataset is incremented only once per event
           break;
         }
 
     for (unsigned int i = 0; i < m_streams.size(); ++i)
       for (unsigned int j: m_streams[i])
         if (hltResults.at(j).accept()) {
           m_stream_counts[i]->Fill(lumisection);
           // ensure each stream is incremented only once per event
           break;
         }
   }
 }

void TriggerRatesMonitor::bookHistograms	(	DQMStore::IBooker &	booker,
		edm::Run const &	run,
		edm::EventSetup const &	setup
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 248 of file TriggerRatesMonitor.cc.

References DQMStore::IBooker::book1D(), HLTConfigProvider::datasetNames(), RecoTau_DiTaus_pt_20-420_cfg::datasets, cmsPerfStripChart::format, MonitorElement::getTH1F(), L1GtTriggerMenu::gtAlgorithmAliasMap(), L1GtTriggerMenu::gtTechnicalTriggerMap(), i, HLTConfigProvider::inited(), j, diffTwoXMLs::label, m_dataset_counts, m_dqm_path, m_events_calibration, m_events_physics, m_events_processed, m_events_random, m_hlt_counts, m_hltConfig, m_hltIndices, m_l1t_algo_counts, m_l1tAlgoMask, m_l1tMenu, m_l1tTechMask, m_lumisections_range, m_stream_counts, HLTConfigProvider::moduleLabel(), HLTConfigProvider::moduleType(), mergeVDriftHistosByStation::name, or, DQMStore::IBooker::setCurrentFolder(), HLTConfigProvider::size(), HLTConfigProvider::streamNames(), hcal_dqm_sourceclient-file_cfg::streams, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, and HLTConfigProvider::triggerName().

 {
   // book the overall event count and event types histograms
   booker.setCurrentFolder( m_dqm_path );
   m_events_processed    = booker.book1D("processed",    "Processed events",     m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
   m_events_physics      = booker.book1D("physics",      "Physics evenst",       m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
   m_events_calibration  = booker.book1D("calibration",  "Calibration events",   m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
   m_events_random       = booker.book1D("random",       "Random events",        m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
 
   if (m_l1tMenu and m_l1tAlgoMask) {
     // book the rate histograms for the L1 Algorithm triggers
     booker.setCurrentFolder( m_dqm_path + "/L1 Algo" );
 
     // book the histograms for L1 algo triggers that are included in the L1 menu
     for (auto const & keyval: m_l1tMenu->gtAlgorithmAliasMap()) {
       int bit = keyval.second.algoBitNumber();
       // check if the trigger is unmasked in *any* partition
       bool masked = ((m_l1tAlgoMask->gtTriggerMask().at(bit) & 0xff) == 0xff);
       std::string const & name  = (boost::format("%s (bit %d)") % keyval.first.substr(0, keyval.first.find_first_of(".")) % bit).str();
       std::string const & title = (boost::format("%s (bit %d)%s") % keyval.first % bit % (masked ? " (masked)" : "")).str();
       m_l1t_algo_counts.at(bit) = booker.book1D(name, title, m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
     }
     // book the histograms for L1 algo triggers that are not included in the L1 menu
     for (unsigned int bit = 0; bit < m_l1tAlgoMask->gtTriggerMask().size(); ++bit) if (not m_l1t_algo_counts.at(bit)) {
       // check if the trigger is unmasked in *any* partition
       bool masked = ((m_l1tAlgoMask->gtTriggerMask().at(bit) & 0xff) == 0xff);
       std::string const & name  = (boost::format("L1 Algo (bit %d)") % bit).str();
       std::string const & title = (boost::format("L1 Algo (bit %d)%s") % bit % (masked ? " (masked)" : "")).str();
       m_l1t_algo_counts.at(bit) = booker.book1D(name, title, m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
     }
   }
 
   if (m_l1tMenu and m_l1tTechMask) {
     // book the rate histograms for the L1 Technical triggers
     booker.setCurrentFolder( m_dqm_path + "/L1 Tech" );
 
     // book the histograms for L1 algo triggers that are included in the L1 menu
     for (auto const & keyval: m_l1tMenu->gtTechnicalTriggerMap()) {
       int bit = keyval.second.algoBitNumber();
       // check if the trigger is unmasked in *any* partition
       bool masked = ((m_l1tTechMask->gtTriggerMask().at(bit) & 0xff) == 0xff);
       std::string const & name  = (boost::format("%s (bit %d)") % keyval.first.substr(0, keyval.first.find_first_of(".")) % bit).str();
       std::string const & title = (boost::format("%s (bit %d)%s") % keyval.first % bit % (masked ? " (masked)" : "")).str();
       m_l1t_algo_counts.at(bit) = booker.book1D(name, title, m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
     }
     // book the histograms for L1 algo triggers that are not included in the L1 menu
     for (unsigned int bit = 0; bit < m_l1tTechMask->gtTriggerMask().size(); ++bit) if (not m_l1t_algo_counts.at(bit)) {
       // check if the trigger is unmasked in *any* partition
       bool masked = ((m_l1tTechMask->gtTriggerMask().at(bit) & 0xff) == 0xff);
       std::string const & name  = (boost::format("L1 Tech (bit %d)") % bit).str();
       std::string const & title = (boost::format("L1 Tech (bit %d)%s") % bit % (masked ? " (masked)" : "")).str();
       m_l1t_algo_counts.at(bit) = booker.book1D(name, title, m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
     }
 
   }
 
   if (m_hltConfig.inited()) {
     // book the HLT triggers rate histograms
     booker.setCurrentFolder( m_dqm_path + "/HLT" );
     for (unsigned int i = 0; i < m_hltConfig.size(); ++i) {
       std::string const & name = m_hltConfig.triggerName(i);
       m_hlt_counts[i].wasrun        = booker.book1D(name + " counts",           name + " counts",           m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       m_hlt_counts[i].pass_l1_seed  = booker.book1D(name + " pass L1 seed",     name + " pass L1 seed",     m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       m_hlt_counts[i].pass_prescale = booker.book1D(name + " pass prescaler",   name + " pass prescaler",   m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       m_hlt_counts[i].accept        = booker.book1D(name + " accept",           name + " accept",           m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       m_hlt_counts[i].reject        = booker.book1D(name + " reject",           name + " reject",           m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       m_hlt_counts[i].error         = booker.book1D(name + " error",            name + " error",            m_lumisections_range + 1,   -0.5,   m_lumisections_range + 0.5)->getTH1F();
       // look for the index of the (last) L1 seed and prescale module in each path
       m_hltIndices[i].index_l1_seed  = m_hltConfig.size(i);
       m_hltIndices[i].index_prescale = m_hltConfig.size(i);
       for (unsigned int j = 0; j < m_hltConfig.size(i); ++j) {
         std::string const & label = m_hltConfig.moduleLabel(i, j);
         std::string const & type  = m_hltConfig.moduleType(label);
         if (type == "HLTLevel1GTSeed" or type == "HLTLevel1Activity" or type == "HLTLevel1Pattern") {
           // there might be more L1 seed filters in sequence
           // keep looking and store the index of the last one
           m_hltIndices[i].index_l1_seed  = j;
         } else if (type == "HLTPrescaler") {
           // there should be only one prescaler in a path, and it should follow all L1 seed filters
           m_hltIndices[i].index_prescale = j;
           break;
         }
 
       }
     }
 
     // book the HLT datasets rate histograms
     booker.setCurrentFolder( m_dqm_path + "/Datasets" );
     auto const & datasets = m_hltConfig.datasetNames();
     for (unsigned int i = 0; i < datasets.size(); ++i)
       m_dataset_counts[i] = booker.book1D(datasets[i], datasets[i], m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
 
     // book the HLT streams rate histograms
     booker.setCurrentFolder( m_dqm_path + "/Streams" );
     auto const & streams = m_hltConfig.streamNames();
     for (unsigned int i = 0; i < streams.size(); ++i)
       m_stream_counts[i]  = booker.book1D(streams[i],  streams[i],  m_lumisections_range + 1, -0.5, m_lumisections_range + 0.5)->getTH1F();
   }
 }

void TriggerRatesMonitor::dqmBeginRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 183 of file TriggerRatesMonitor.cc.

References begin, dataset::dataset, HLTConfigProvider::datasetContent(), HLTConfigProvider::datasetNames(), RecoTau_DiTaus_pt_20-420_cfg::datasets, end, i, HLTConfigProvider::init(), tablePrinter::labels, edm::EDConsumerBase::labelsForToken(), m_dataset_counts, m_datasets, m_events_calibration, m_events_physics, m_events_processed, m_events_random, m_hlt_counts, m_hlt_results, m_hltConfig, m_hltIndices, m_l1t_algo_counts, m_l1t_tech_counts, m_l1tAlgoMask, m_l1tMenu, m_l1tTechMask, m_stream_counts, m_streams, nullptr, cmsHarvester::path, mergeAndRegister::paths, edm::EDConsumerBase::Labels::process, HcalObjRepresent::setup(), HLTConfigProvider::size(), python.multivaluedict::sort(), HLTConfigProvider::streamContent(), HLTConfigProvider::streamNames(), hcal_dqm_sourceclient-file_cfg::streams, and HLTConfigProvider::triggerIndex().

 {
   m_events_processed    = nullptr;
   m_events_physics      = nullptr;
   m_events_calibration  = nullptr;
   m_events_random       = nullptr;
 
   // cache the L1 trigger menu
   m_l1tMenu     = get<L1GtTriggerMenuRcd, L1GtTriggerMenu>(setup);
   // FIXME - do we really need this ?
   //(const_cast<L1GtTriggerMenu *>(m_l1tMenu))->buildGtConditionMap();
   m_l1tAlgoMask = get<L1GtTriggerMaskAlgoTrigRcd, L1GtTriggerMask>(setup);
   m_l1tTechMask = get<L1GtTriggerMaskTechTrigRcd, L1GtTriggerMask>(setup);
   if (m_l1tMenu and m_l1tAlgoMask and m_l1tTechMask) {
     m_l1t_algo_counts.clear();
     m_l1t_algo_counts.resize( m_l1tAlgoMask->gtTriggerMask().size(), nullptr );
     m_l1t_tech_counts.clear();
     m_l1t_tech_counts.resize( m_l1tTechMask->gtTriggerMask().size(), nullptr );
   } else {
     // L1GtUtils not initialised, skip the the L1T monitoring
     edm::LogError("TriggerRatesMonitor") << "failed to read the L1 menu or masks from the EventSetup, the L1 trigger rates will not be monitored";
   }
 
   // initialise the HLTConfigProvider
   bool changed = true;
   edm::EDConsumerBase::Labels labels;
   labelsForToken(m_hlt_results, labels);
   if (m_hltConfig.init(run, setup, labels.process, changed)) {
     m_hlt_counts.clear();
     m_hlt_counts.resize( m_hltConfig.size(), HLTRatesPlots() );
     m_hltIndices.resize( m_hltConfig.size(), HLTIndices() );
 
     unsigned int datasets = m_hltConfig.datasetNames().size();
     m_datasets.clear();
     m_datasets.resize( datasets, {} );
     for (unsigned int i = 0; i < datasets; ++i) {
       auto const & paths = m_hltConfig.datasetContent(i);
       m_datasets[i].reserve(paths.size());
       for (auto const & path: paths)
         m_datasets[i].push_back(m_hltConfig.triggerIndex(path));
     }
     m_dataset_counts.clear();
     m_dataset_counts.resize( datasets, nullptr );
 
     unsigned int streams = m_hltConfig.streamNames().size();
     m_streams.clear();
     m_streams.resize( streams, {} );
     for (unsigned int i = 0; i < streams; ++i) {
       for (auto const & dataset : m_hltConfig.streamContent(i)) {
         for (auto const & path : m_hltConfig.datasetContent(dataset))
           m_streams[i].push_back(m_hltConfig.triggerIndex(path));
       }
       std::sort(m_streams[i].begin(), m_streams[i].end());
       auto unique_end = std::unique(m_streams[i].begin(), m_streams[i].end());
       m_streams[i].resize(unique_end - m_streams[i].begin());
       m_streams[i].shrink_to_fit();
     }
     m_stream_counts.clear();
     m_stream_counts.resize( streams, nullptr );
   } else {
     // HLTConfigProvider not initialised, skip the the HLT monitoring
     edm::LogError("TriggerRatesMonitor") << "failed to initialise HLTConfigProvider, the HLT trigger and datasets rates will not be monitored";
   }
 }

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

static

Definition at line 137 of file TriggerRatesMonitor.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
   edm::ParameterSetDescription desc;
   desc.addUntracked<edm::InputTag>( "l1tResults",       edm::InputTag("gtDigis"));
   desc.addUntracked<edm::InputTag>( "hltResults",       edm::InputTag("TriggerResults"));
   desc.addUntracked<std::string>(   "dqmPath",          "HLT/TriggerRates" );
   desc.addUntracked<uint32_t>(      "lumisectionRange", 2500 );             // ~16 hours
   descriptions.add("triggerRatesMonitor", desc);
 }