Inheritance diagram for HLTriggerJSONMonitoring:

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

std::unique_ptr< HLTriggerJSONMonitoringData::stream >	beginStream (edm::StreamID) const override

std::shared_ptr< HLTriggerJSONMonitoringData::lumisection >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &) const override

std::shared_ptr< HLTriggerJSONMonitoringData::run >	globalBeginRun (edm::Run const &, edm::EventSetup const &) const override

void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, HLTriggerJSONMonitoringData::lumisection *) const override

void	globalEndRun (edm::Run const &, edm::EventSetup const &) const override

	HLTriggerJSONMonitoring (const edm::ParameterSet &)

void	streamBeginLuminosityBlock (edm::StreamID, edm::LuminosityBlock const &, edm::EventSetup const &) const override

void	streamEndLuminosityBlockSummary (edm::StreamID, edm::LuminosityBlock const &, edm::EventSetup const &, HLTriggerJSONMonitoringData::lumisection *) const override

	~HLTriggerJSONMonitoring () override=default

Public Member Functions inherited from edm::global::EDAnalyzer< edm::StreamCache< HLTriggerJSONMonitoringData::stream >, edm::RunCache< HLTriggerJSONMonitoringData::run >, edm::LuminosityBlockSummaryCache< HLTriggerJSONMonitoringData::lumisection > >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Static Private Member Functions
static void	writeIniFile (HLTriggerJSONMonitoringData::run const &, unsigned int)

static void	writeJsdFile (HLTriggerJSONMonitoringData::run const &)

Private Attributes
const edm::InputTag	triggerResults_

const edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_

Static Private Attributes
static constexpr const char *	datasetPathNamePrefix_ = "Dataset_"

static constexpr const char *	streamName_ = "streamHLTRates"

Additional Inherited Members
Public Types inherited from edm::global::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: This class outputs JSON files with HLT monitoring information.

Definition at line 81 of file HLTriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

◆ HLTriggerJSONMonitoring()

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

explicit

Definition at line 149 of file HLTriggerJSONMonitoring.cc.

References Exception, geometryDiff::file, and AlCaHLTBitMon_QueryRunRegistry::string.

     : triggerResults_(config.getParameter<edm::InputTag>("triggerResults")),
       triggerResultsToken_(consumes(triggerResults_)) {
   if (edm::Service<evf::EvFDaqDirector>().isAvailable()) {
     //output initemp file. This lets hltd know number of streams early
     std::string initFileName = edm::Service<evf::EvFDaqDirector>()->getInitTempFilePath("streamHLTRates");
     std::ofstream file(initFileName);
     if (!file)
       throw cms::Exception("HLTriggerJsonMonitoring")
           << "Cannot create INITEMP file: " << initFileName << " error: " << strerror(errno);
     file.close();
   }
 }

◆ ~HLTriggerJSONMonitoring()

HLTriggerJSONMonitoring::~HLTriggerJSONMonitoring ( )

overridedefault

Member Function Documentation

◆ analyze()

void HLTriggerJSONMonitoring::analyze	(	edm::StreamID	sid,
		edm::Event const &	event,
		edm::EventSetup const &
	)		const

overridevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 275 of file HLTriggerJSONMonitoring.cc.

References cms::cuda::assert(), edm::InputTag::encode(), patZpeak::handle, mps_fire::i, heavyIonCSV_trainingSettings::idx, createfilelist::int, or, castor_dqm_sourceclient_file_cfg::path, mysort::results, mps_update::status, cms::cuda::stream, triggerResults_, and triggerResultsToken_.

                                                                                                         {
   auto& stream = *streamCache(sid);
   auto const& rundata = *runCache(event.getRun().index());
 
   ++stream.processed;
 
   // check that the HLTConfigProvider for the current run has been successfully initialised
   if (not rundata.hltConfig.inited())
     return;
 
   // get hold of TriggerResults
   edm::Handle<edm::TriggerResults> handle;
   if (not event.getByToken(triggerResultsToken_, handle) or not handle.isValid()) {
     edm::LogError("HLTriggerJSONMonitoring")
         << "TriggerResults with label [" + triggerResults_.encode() + "] not present or invalid";
     return;
   }
   edm::TriggerResults const& results = *handle;
   assert(results.size() == rundata.hltConfig.triggerNames().size());
 
   // check the results for each HLT path
   for (auto idx = 0u; idx < rundata.indicesOfTriggerPaths.size(); ++idx) {
     auto const triggerPathIdx = rundata.indicesOfTriggerPaths[idx];
     auto const& status = results[triggerPathIdx];
     if (status.wasrun()) {
       ++stream.hltWasRun[idx];
       if (status.accept()) {
         ++stream.hltPrePS[idx];
         ++stream.hltPostPS[idx];
         ++stream.hltAccept[idx];
       } else {
         int const index = (int)status.index();
         if (index >= rundata.posPre[idx])
           ++stream.hltPrePS[idx];
         if (index > rundata.posPre[idx])
           ++stream.hltPostPS[idx];
         if (status.error())
           ++stream.hltErrors[idx];
         else
           ++stream.hltReject[idx];
       }
     }
   }
 
   // check the decision for each dataset
   // FIXME this ignores the prescales, "smart" prescales, and event selection applied in the OutputModule itself
   for (auto i = 0u; i < rundata.datasets.size(); ++i)
     if (std::any_of(rundata.datasets[i].begin(), rundata.datasets[i].end(), [&](unsigned int path) {
           return results.accept(path);
         }))
       ++stream.datasets[i];
 }

◆ beginStream()

std::unique_ptr< HLTriggerJSONMonitoringData::stream > HLTriggerJSONMonitoring::beginStream ( edm::StreamID ) const

override

Definition at line 171 of file HLTriggerJSONMonitoring.cc.

                                                                                                        {
   return std::make_unique<HLTriggerJSONMonitoringData::stream>();
 }

◆ fillDescriptions()

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

static

Definition at line 164 of file HLTriggerJSONMonitoring.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("triggerResults", edm::InputTag("TriggerResults", "", "@currentProcess"));
   descriptions.add("HLTriggerJSONMonitoring", desc);
 }

◆ globalBeginLuminosityBlockSummary()

std::shared_ptr< HLTriggerJSONMonitoringData::lumisection > HLTriggerJSONMonitoring::globalBeginLuminosityBlockSummary	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &
	)		const

override

Definition at line 329 of file HLTriggerJSONMonitoring.cc.

References contentValuesFiles::datasets, and mps_fire::i.

                                                                 {
   unsigned int triggers = 0;
   unsigned int datasets = 0;
   auto const& rundata = *runCache(lumi.getRun().index());
   if (rundata.hltConfig.inited()) {
     triggers = rundata.indicesOfTriggerPaths.size();
     datasets = rundata.hltConfig.datasetNames().size();
   };
 
   // the API of jsoncollector::HistoJ does not really match our use case,
   // but it is the only vector-like object available in JsonMonitorable.h
   auto lumidata = std::make_shared<HLTriggerJSONMonitoringData::lumisection>(HLTriggerJSONMonitoringData::lumisection{
       jsoncollector::HistoJ<unsigned int>(1),         // processed
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltWasRun
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltPrePS
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltPostPS
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltAccept
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltReject
       jsoncollector::HistoJ<unsigned int>(triggers),  // hltErrors
       jsoncollector::HistoJ<unsigned int>(datasets)   // datasets
   });
   // repeated calls to `update` necessary to set the internal element counter
   lumidata->processed.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltWasRun.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltPrePS.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltPostPS.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltAccept.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltReject.update(0);
   for (unsigned int i = 0; i < triggers; ++i)
     lumidata->hltErrors.update(0);
   for (unsigned int i = 0; i < datasets; ++i)
     lumidata->datasets.update(0);
 
   return lumidata;
 }

◆ globalBeginRun()

std::shared_ptr< HLTriggerJSONMonitoringData::run > HLTriggerJSONMonitoring::globalBeginRun	(	edm::Run const &	run,
		edm::EventSetup const &	setup
	)		const

override

Definition at line 176 of file HLTriggerJSONMonitoring.cc.

References makeLayoutFileForGui::datasetNames, datasetPathNamePrefix_, contentValuesFiles::datasets, spr::find(), mps_fire::i, edm::Service< T >::isAvailable(), dqmiolumiharvest::j, evf::MergeTypeJSNDATA, AlCaHLTBitMon_ParallelJobs::p, Skims_PA_cff::paths, edm::InputTag::process(), writedatasetfile::run, singleTopDQM_cfi::setup, streamName_, L1TEGammaOffline_cfi::triggerNames, triggerResults_, writeIniFile(), and writeJsdFile().

                                                          {
   auto rundata = std::make_shared<HLTriggerJSONMonitoringData::run>();
 
   // set the DAQ parameters
   if (edm::Service<evf::EvFDaqDirector>().isAvailable()) {
     rundata->streamDestination = edm::Service<evf::EvFDaqDirector>()->getStreamDestinations(streamName_);
     rundata->streamMergeType =
         edm::Service<evf::EvFDaqDirector>()->getStreamMergeType(streamName_, evf::MergeTypeJSNDATA);
     rundata->baseRunDir = edm::Service<evf::EvFDaqDirector>()->baseRunDir();
   } else {
     rundata->streamDestination = "";
     rundata->streamMergeType = "";
     rundata->baseRunDir = ".";
   }
 
   // initialize HLTConfigProvider
   bool changed = true;
   if (not rundata->hltConfig.init(run, setup, triggerResults_.process(), changed)) {
     edm::LogError("HLTriggerJSONMonitoring") << "HLTConfigProvider initialization failed!";
   } else if (changed) {
     // triggerNames from TriggerResults (includes DatasetPaths)
     auto const& triggerNames = rundata->hltConfig.triggerNames();
     auto const triggerNamesSize = triggerNames.size();
 
     // update the list of indices of the HLT Paths (without DatasetPaths) in the TriggerNames list
     rundata->indicesOfTriggerPaths.clear();
     rundata->indicesOfTriggerPaths.reserve(triggerNamesSize);
     for (auto triggerNameIdx = 0u; triggerNameIdx < triggerNamesSize; ++triggerNameIdx) {
       // skip DatasetPaths
       if (triggerNames[triggerNameIdx].find(datasetPathNamePrefix_) != 0) {
         rundata->indicesOfTriggerPaths.emplace_back(triggerNameIdx);
       }
     }
     auto const triggersSize = rundata->indicesOfTriggerPaths.size();
 
     // update the list of paths in each dataset
     auto const& datasets = rundata->hltConfig.datasetContents();
     auto const& datasetNames = rundata->hltConfig.datasetNames();
     auto const datasetsSize = datasetNames.size();
     rundata->datasets.resize(datasetsSize);
     for (auto ds = 0u; ds < datasetsSize; ++ds) {
       auto& dataset = rundata->datasets[ds];
       // check if TriggerNames include the DatasetPath corresponding to this Dataset
       //  - DatasetPaths are normal cms.Path objects
       //  - in Run-3 HLT menus, DatasetPaths are used to define PrimaryDatasets
       auto const datasetPathName = datasetPathNamePrefix_ + datasetNames[ds];
       auto const datasetPathExists =
           std::find(triggerNames.begin(), triggerNames.end(), datasetPathName) != triggerNames.end();
       if (datasetPathExists) {
         // if a DatasetPath exists, only that Path is assigned to the Dataset
         //  - this way, the counts of the Dataset properly include prescales on the DatasetPath
         //    and smart-Prescales applied by the DatasetPath to its triggers
         dataset.reserve(1);
         auto const index = rundata->hltConfig.triggerIndex(datasetPathName);
         if (index < triggerNamesSize)
           dataset.push_back(index);
       } else {
         auto const paths = datasets[ds].size();
         dataset.reserve(paths);
         for (auto p = 0u; p < paths; p++) {
           auto const index = rundata->hltConfig.triggerIndex(datasets[ds][p]);
           if (index < triggerNamesSize)
             dataset.push_back(index);
         }
       }
     }
 
     // find the positions of the prescale filters
     rundata->posPre.resize(triggersSize);
     for (auto i = 0u; i < triggersSize; ++i) {
       rundata->posPre[i] = -1;
       auto const trigNameIndx = rundata->indicesOfTriggerPaths[i];
       auto const& moduleLabels = rundata->hltConfig.moduleLabels(trigNameIndx);
       for (auto j = 0u; j < moduleLabels.size(); ++j) {
         auto const& moduleType = rundata->hltConfig.moduleType(moduleLabels[j]);
         if (moduleType == "HLTPrescaler") {
           rundata->posPre[i] = j;
           break;
         }
       }
     }
   }
 
   // write the per-run .jsd file
   rundata->jsdFileName = fmt::sprintf("run%06d_ls0000_streamHLTRates_pid%05d.jsd", run.run(), getpid());
   writeJsdFile(*rundata);
 
   // write the per-run .ini file
   //iniFileName = fmt::sprintf("run%06d_ls0000_streamHLTRates_pid%05d.ini", run.run(), getpid());
   writeIniFile(*rundata, run.run());
 
   return rundata;
 }

◆ globalEndLuminosityBlockSummary()

void HLTriggerJSONMonitoring::globalEndLuminosityBlockSummary	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	,
		HLTriggerJSONMonitoringData::lumisection *	lumidata
	)		const

override

Definition at line 424 of file HLTriggerJSONMonitoring.cc.

                                                                                                                       {
   unsigned int ls = lumi.luminosityBlock();
   unsigned int run = lumi.run();
 
   bool writeFiles = true;
   if (edm::Service<evf::MicroStateService>().isAvailable()) {
     evf::FastMonitoringService* fms =
         (evf::FastMonitoringService*)(edm::Service<evf::MicroStateService>().operator->());
     if (fms)
       writeFiles = fms->shouldWriteFiles(ls);
   }
   if (not writeFiles)
     return;
 
   unsigned int processed = lumidata->processed.value().at(0);
   auto const& rundata = *runCache(lumi.getRun().index());
   Json::StyledWriter writer;
 
   // [SIC]
   char hostname[33];
   gethostname(hostname, 32);
   std::string sourceHost(hostname);
 
   // [SIC]
   std::stringstream sOutDef;
   sOutDef << rundata.baseRunDir << "/"
           << "output_" << getpid() << ".jsd";
 
   std::string jsndataFileList = "";
   unsigned int jsndataSize = 0;
   unsigned int jsndataAdler32 = 1;  // adler32 checksum for an empty file
 
   if (processed) {
     // write the .jsndata files which contain the actual rates
     Json::Value jsndata;
     jsndata[jsoncollector::DataPoint::SOURCE] = sourceHost;
     jsndata[jsoncollector::DataPoint::DEFINITION] = rundata.jsdFileName;
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->processed.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltWasRun.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltPrePS.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltPostPS.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltAccept.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltReject.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltErrors.toJsonValue());
     jsndata[jsoncollector::DataPoint::DATA].append(lumidata->datasets.toJsonValue());
 
     auto jsndataFileName = fmt::sprintf("run%06d_ls%04d_streamHLTRates_pid%05d.jsndata", run, ls, getpid());
 
     std::string result = writer.write(jsndata);
     std::ofstream jsndataFile(rundata.baseRunDir + "/" + jsndataFileName);
     jsndataFile << result;
     jsndataFile.close();
 
     jsndataFileList = jsndataFileName;
     jsndataSize = result.size();
     jsndataAdler32 = cms::Adler32(result.c_str(), result.size());
   }
 
   // create a metadata json file for the "HLT rates" pseudo-stream
   unsigned int jsnProcessed = processed;
   unsigned int jsnAccepted = processed;
   unsigned int jsnErrorEvents = 0;
   unsigned int jsnRetCodeMask = 0;
   std::string jsnInputFiles = "";
   unsigned int jsnHLTErrorEvents = 0;
 
   Json::Value jsn;
   jsn[jsoncollector::DataPoint::SOURCE] = sourceHost;
   jsn[jsoncollector::DataPoint::DEFINITION] = sOutDef.str();
   jsn[jsoncollector::DataPoint::DATA].append(jsnProcessed);
   jsn[jsoncollector::DataPoint::DATA].append(jsnAccepted);
   jsn[jsoncollector::DataPoint::DATA].append(jsnErrorEvents);
   jsn[jsoncollector::DataPoint::DATA].append(jsnRetCodeMask);
   jsn[jsoncollector::DataPoint::DATA].append(jsndataFileList);
   jsn[jsoncollector::DataPoint::DATA].append(jsndataSize);
   jsn[jsoncollector::DataPoint::DATA].append(jsnInputFiles);
   jsn[jsoncollector::DataPoint::DATA].append(jsndataAdler32);
   jsn[jsoncollector::DataPoint::DATA].append(rundata.streamDestination);
   jsn[jsoncollector::DataPoint::DATA].append(rundata.streamMergeType);
   jsn[jsoncollector::DataPoint::DATA].append(jsnHLTErrorEvents);
 
   auto jsnFileName = fmt::sprintf("run%06d_ls%04d_streamHLTRates_pid%05d.jsn", run, ls, getpid());
   std::ofstream jsnFile(rundata.baseRunDir + "/" + jsnFileName);
   jsnFile << writer.write(jsn);
   jsnFile.close();
 }

◆ globalEndRun()

void HLTriggerJSONMonitoring::globalEndRun	(	edm::Run const &	,
		edm::EventSetup const &
	)		const

override

Definition at line 272 of file HLTriggerJSONMonitoring.cc.

272 {}

◆ streamBeginLuminosityBlock()

void HLTriggerJSONMonitoring::streamBeginLuminosityBlock	(	edm::StreamID	sid,
		edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &
	)		const

override

Definition at line 372 of file HLTriggerJSONMonitoring.cc.

References contentValuesFiles::datasets, and cms::cuda::stream.

                                                                                      {
   auto& stream = *streamCache(sid);
 
   unsigned int triggers = 0;
   unsigned int datasets = 0;
   auto const& rundata = *runCache(lumi.getRun().index());
   if (rundata.hltConfig.inited()) {
     triggers = rundata.indicesOfTriggerPaths.size();
     datasets = rundata.hltConfig.datasetNames().size();
   };
 
   // reset the stream counters
   stream.processed = 0;
   stream.hltWasRun.assign(triggers, 0);
   stream.hltPrePS.assign(triggers, 0);
   stream.hltPostPS.assign(triggers, 0);
   stream.hltAccept.assign(triggers, 0);
   stream.hltReject.assign(triggers, 0);
   stream.hltErrors.assign(triggers, 0);
   stream.datasets.assign(datasets, 0);
 }

◆ streamEndLuminosityBlockSummary()

void HLTriggerJSONMonitoring::streamEndLuminosityBlockSummary	(	edm::StreamID	sid,
		edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	,
		HLTriggerJSONMonitoringData::lumisection *	lumidata
	)		const

override

Definition at line 397 of file HLTriggerJSONMonitoring.cc.

                                                                                                                       {
   auto const& stream = *streamCache(sid);
   auto const& rundata = *runCache(lumi.getRun().index());
   lumidata->processed.value()[0] += stream.processed;
 
   // check that the HLTConfigProvider for the current run has been successfully initialised
   if (not rundata.hltConfig.inited())
     return;
 
   auto const triggers = rundata.indicesOfTriggerPaths.size();
   for (auto i = 0u; i < triggers; ++i) {
     lumidata->hltWasRun.value()[i] += stream.hltWasRun[i];
     lumidata->hltPrePS.value()[i] += stream.hltPrePS[i];
     lumidata->hltPostPS.value()[i] += stream.hltPostPS[i];
     lumidata->hltAccept.value()[i] += stream.hltAccept[i];
     lumidata->hltReject.value()[i] += stream.hltReject[i];
     lumidata->hltErrors.value()[i] += stream.hltErrors[i];
   }
   auto const datasets = rundata.hltConfig.datasetNames().size();
   for (auto i = 0u; i < datasets; ++i)
     lumidata->datasets.value()[i] += stream.datasets[i];
 }

◆ writeIniFile()

void HLTriggerJSONMonitoring::writeIniFile	(	HLTriggerJSONMonitoringData::run const &	rundata,
		unsigned int	run
	)

staticprivate

Definition at line 531 of file HLTriggerJSONMonitoring.cc.

References Json::arrayValue, HLTriggerJSONMonitoringData::run::baseRunDir, Skims_PA_cff::content, makeLayoutFileForGui::datasetNames, HLTConfigProvider::datasetNames(), geometryDiff::file, HLTriggerJSONMonitoringData::run::hltConfig, heavyIonCSV_trainingSettings::idx, HLTriggerJSONMonitoringData::run::indicesOfTriggerPaths, Skims_PA_cff::name, writedatasetfile::run, AlCaHLTBitMon_QueryRunRegistry::string, L1TEGammaOffline_cfi::triggerNames, HLTConfigProvider::triggerNames(), and convertToRaw::writer.

Referenced by globalBeginRun().

                                                                                                           {
   Json::Value content;
 
   Json::Value triggerNames(Json::arrayValue);
   for (auto idx : rundata.indicesOfTriggerPaths)
     triggerNames.append(rundata.hltConfig.triggerNames()[idx]);
   content["Path-Names"] = triggerNames;
 
   Json::Value datasetNames(Json::arrayValue);
   for (auto const& name : rundata.hltConfig.datasetNames())
     datasetNames.append(name);
   content["Dataset-Names"] = datasetNames;
 
   std::string iniFileName = fmt::sprintf("run%06d_ls0000_streamHLTRates_pid%05d.ini", run, getpid());
   std::ofstream file(rundata.baseRunDir + "/" + iniFileName);
   Json::StyledWriter writer;
   file << writer.write(content);
   file.close();
 }

◆ writeJsdFile()

void HLTriggerJSONMonitoring::writeJsdFile ( HLTriggerJSONMonitoringData::run const & rundata )

staticprivate

Definition at line 513 of file HLTriggerJSONMonitoring.cc.

References HLTriggerJSONMonitoringData::run::baseRunDir, geometryDiff::file, and HLTriggerJSONMonitoringData::run::jsdFileName.

Referenced by globalBeginRun().

                                                                                         {
   std::ofstream file(rundata.baseRunDir + "/" + rundata.jsdFileName);
   file << R"""({
    "data" : [
       { "name" : "Processed", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-WasRun", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-AfterL1Seed", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-AfterPrescale", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-Accepted", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-Rejected", "type" : "integer", "operation" : "histo"},
       { "name" : "Path-Errors", "type" : "integer", "operation" : "histo"},
       { "name" : "Dataset-Accepted", "type" : "integer", "operation" : "histo"}
    ]
 }
 )""";
   file.close();
 }