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
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 &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
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 &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
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 *	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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

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

Definition at line 70 of file HLTriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

HLTriggerJSONMonitoring()

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

explicit

Definition at line 136 of file HLTriggerJSONMonitoring.cc.

    : triggerResults_(config.getParameter<edm::InputTag>("triggerResults")),
      triggerResultsToken_(consumes<edm::TriggerResults>(triggerResults_)) {}

~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 227 of file HLTriggerJSONMonitoring.cc.

                                                                                                        {
  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() == stream.hltWasRun.size());
 
  // check the results for each HLT path
  for (unsigned int i = 0; i < results.size(); ++i) {
    auto const& status = results.at(i);
    if (status.wasrun()) {
      ++stream.hltWasRun[i];
      if (status.accept()) {
        ++stream.hltL1s[i];
        ++stream.hltPre[i];
        ++stream.hltAccept[i];
      } else {
        int index = (int)status.index();
        if (index > rundata.posL1s[i])
          ++stream.hltL1s[i];
        if (index > rundata.posPre[i])
          ++stream.hltPre[i];
        if (status.error())
          ++stream.hltErrors[i];
        else
          ++stream.hltReject[i];
      }
    }
  }
 
  // check the decision for each dataset
  // FIXME this ignores the prescales, "smart" prescales, and event selection applied in the OutputModule itself
  for (unsigned int i = 0; 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];
}

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

beginStream()

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

override

Definition at line 148 of file HLTriggerJSONMonitoring.cc.

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

fillDescriptions()

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

static

Definition at line 141 of file HLTriggerJSONMonitoring.cc.

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

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

globalBeginLuminosityBlockSummary()

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

override

Definition at line 280 of file HLTriggerJSONMonitoring.cc.

                                                                {
  unsigned int triggers = 0;
  unsigned int datasets = 0;
  auto const& rundata = *runCache(lumi.getRun().index());
  if (rundata.hltConfig.inited()) {
    triggers = rundata.hltConfig.triggerNames().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),  // hltL1s
      jsoncollector::HistoJ<unsigned int>(triggers),  // hltPre
      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->hltL1s.update(0);
  for (unsigned int i = 0; i < triggers; ++i)
    lumidata->hltPre.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;
}

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

globalBeginRun()

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

override

Definition at line 153 of file HLTriggerJSONMonitoring.cc.

                                                         {
  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!" << std::endl;
  } else if (changed) {
    // update the trigger and dataset names
    auto const& triggerNames = rundata->hltConfig.triggerNames();
    auto const& datasetNames = rundata->hltConfig.datasetNames();
    auto const& datasets = rundata->hltConfig.datasetContents();
 
    const unsigned int triggersSize = triggerNames.size();
    const unsigned int datasetsSize = datasetNames.size();
 
    // extract the definition of the datasets
    rundata->datasets.resize(datasetsSize);
    for (unsigned int ds = 0; ds < datasetsSize; ++ds) {
      auto& dataset = rundata->datasets[ds];
      unsigned int paths = datasets[ds].size();
      dataset.reserve(paths);
      for (unsigned int p = 0; p < paths; p++) {
        unsigned int index = rundata->hltConfig.triggerIndex(datasets[ds][p]);
        if (index < triggersSize)
          dataset.push_back(index);
      }
    }
 
    // find the positions of the L1 seed and prescale filters
    rundata->posL1s.resize(triggersSize);
    rundata->posPre.resize(triggersSize);
    for (unsigned int i = 0; i < triggersSize; ++i) {
      rundata->posL1s[i] = -1;
      rundata->posPre[i] = -1;
      std::vector<std::string> const& moduleLabels = rundata->hltConfig.moduleLabels(i);
      for (unsigned int j = 0; j < moduleLabels.size(); ++j) {
        std::string const& label = rundata->hltConfig.moduleType(moduleLabels[j]);
        if (label == "HLTL1TSeed")
          rundata->posL1s[i] = j;
        else if (label == "HLTPrescaler")
          rundata->posPre[i] = j;
      }
    }
  }
 
  // 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;
}

References makeLayoutFileForGui::datasetNames, contentValuesFiles::datasets, mps_fire::i, dqmiolumiharvest::j, label, evf::MergeTypeJSNDATA, AlCaHLTBitMon_ParallelJobs::p, Skims_PA_cff::paths, edm::InputTag::process(), writedatasetfile::run, singleTopDQM_cfi::setup, streamName_, AlCaHLTBitMon_QueryRunRegistry::string, L1TEGammaOffline_cfi::triggerNames, triggerResults_, writeIniFile(), and writeJsdFile().

globalEndLuminosityBlockSummary()

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

override

Definition at line 375 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->hltL1s.toJsonValue());
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->hltPre.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();
}

References cms::Adler32(), Json::Value::append(), jsoncollector::DataPoint::DATA, HLTriggerJSONMonitoringData::lumisection::datasets, jsoncollector::DataPoint::DEFINITION, HLTriggerJSONMonitoringData::lumisection::hltAccept, HLTriggerJSONMonitoringData::lumisection::hltErrors, HLTriggerJSONMonitoringData::lumisection::hltL1s, HLTriggerJSONMonitoringData::lumisection::hltPre, 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 cscNeutronWriter_cfi::writer.

globalEndRun()

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

override

Definition at line 224 of file HLTriggerJSONMonitoring.cc.

{}

streamBeginLuminosityBlock()

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

override

Definition at line 323 of file HLTriggerJSONMonitoring.cc.

                                                                                     {
  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.hltConfig.triggerNames().size();
    datasets = rundata.hltConfig.datasetNames().size();
  };
 
  // reset the stream counters
  stream.processed = 0;
  stream.hltWasRun.assign(triggers, 0);
  stream.hltL1s.assign(triggers, 0);
  stream.hltPre.assign(triggers, 0);
  stream.hltAccept.assign(triggers, 0);
  stream.hltReject.assign(triggers, 0);
  stream.hltErrors.assign(triggers, 0);
  stream.datasets.assign(datasets, 0);
}

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

streamEndLuminosityBlockSummary()

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

override

Definition at line 348 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;
 
  unsigned int triggers = rundata.hltConfig.triggerNames().size();
  for (unsigned int i = 0; i < triggers; ++i) {
    lumidata->hltWasRun.value()[i] += stream.hltWasRun[i];
    lumidata->hltL1s.value()[i] += stream.hltL1s[i];
    lumidata->hltPre.value()[i] += stream.hltPre[i];
    lumidata->hltAccept.value()[i] += stream.hltAccept[i];
    lumidata->hltReject.value()[i] += stream.hltReject[i];
    lumidata->hltErrors.value()[i] += stream.hltErrors[i];
  }
  unsigned int datasets = rundata.hltConfig.datasetNames().size();
  for (unsigned int i = 0; i < datasets; ++i)
    lumidata->datasets.value()[i] += stream.datasets[i];
}

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

writeIniFile()

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

staticprivate

Definition at line 482 of file HLTriggerJSONMonitoring.cc.

                                                                                                          {
  Json::Value content;
 
  Json::Value triggerNames(Json::arrayValue);
  for (auto const& name : rundata.hltConfig.triggerNames())
    triggerNames.append(name);
  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();
}

References Json::arrayValue, HLTriggerJSONMonitoringData::run::baseRunDir, Skims_PA_cff::content, makeLayoutFileForGui::datasetNames, HLTConfigProvider::datasetNames(), FrontierConditions_GlobalTag_cff::file, HLTriggerJSONMonitoringData::run::hltConfig, Skims_PA_cff::name, writedatasetfile::run, AlCaHLTBitMon_QueryRunRegistry::string, L1TEGammaOffline_cfi::triggerNames, HLTConfigProvider::triggerNames(), and cscNeutronWriter_cfi::writer.

Referenced by globalBeginRun().

writeJsdFile()

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

staticprivate

Definition at line 464 of file HLTriggerJSONMonitoring.cc.

                                                                                        {
  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();
}

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

Referenced by globalBeginRun().

Member Data Documentation

streamName_

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

staticconstexprprivate

Definition at line 125 of file HLTriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

triggerResults_

const edm::InputTag HLTriggerJSONMonitoring::triggerResults_

private

Definition at line 131 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze(), and globalBeginRun().

triggerResultsToken_

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

private

Definition at line 132 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze().