HLTriggerJSONMonitoring Class Reference

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
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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 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 83 of file HLTriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

HLTriggerJSONMonitoring()

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

explicit

Definition at line 151 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 277 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 173 of file HLTriggerJSONMonitoring.cc.

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

fillDescriptions()

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

static

Definition at line 166 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 331 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 178 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 426 of file HLTriggerJSONMonitoring.cc.

References cms::Adler32(), jsoncollector::Json::Value::append(), jsoncollector::DataPoint::DATA, HLTriggerJSONMonitoringData::lumisection::datasets, jsoncollector::DataPoint::DEFINITION, HLTriggerJSONMonitoringData::lumisection::hltAccept, HLTriggerJSONMonitoringData::lumisection::hltErrors, HLTriggerJSONMonitoringData::lumisection::hltPostPS, HLTriggerJSONMonitoringData::lumisection::hltPrePS, HLTriggerJSONMonitoringData::lumisection::hltReject, HLTriggerJSONMonitoringData::lumisection::hltWasRun, eostools::ls(), HLTriggerJSONMonitoringData::lumisection::processed, mps_fire::result, writedatasetfile::run, evf::FastMonitoringService::shouldWriteFiles(), jsoncollector::DataPoint::SOURCE, AlCaHLTBitMon_QueryRunRegistry::string, jsoncollector::HistoJ< T >::toJsonValue(), jsoncollector::HistoJ< T >::value(), and convertToRaw::writer.

                                                                                                                      {
  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 274 of file HLTriggerJSONMonitoring.cc.

{}

streamBeginLuminosityBlock()

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

override

Definition at line 374 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 399 of file HLTriggerJSONMonitoring.cc.

References contentValuesFiles::datasets, HLTriggerJSONMonitoringData::lumisection::datasets, HLTriggerJSONMonitoringData::lumisection::hltAccept, HLTriggerJSONMonitoringData::lumisection::hltErrors, HLTriggerJSONMonitoringData::lumisection::hltPostPS, HLTriggerJSONMonitoringData::lumisection::hltPrePS, HLTriggerJSONMonitoringData::lumisection::hltReject, HLTriggerJSONMonitoringData::lumisection::hltWasRun, mps_fire::i, HLTriggerJSONMonitoringData::lumisection::processed, cms::cuda::stream, and jsoncollector::HistoJ< T >::value().

                                                                                                                      {
  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 533 of file HLTriggerJSONMonitoring.cc.

References jsoncollector::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 515 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();
}

Member Data Documentation

datasetPathNamePrefix_

constexpr const char* HLTriggerJSONMonitoring::datasetPathNamePrefix_ = "Dataset_"

staticprivate

Definition at line 140 of file HLTriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

streamName_

constexpr const char* HLTriggerJSONMonitoring::streamName_ = "streamHLTRates"

staticprivate

Definition at line 138 of file HLTriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

triggerResults_

const edm::InputTag HLTriggerJSONMonitoring::triggerResults_

private

Definition at line 146 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze(), and globalBeginRun().

triggerResultsToken_

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

private

Definition at line 147 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze().