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< T >
	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 *	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 () noexcept
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...
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 70 of file HLTriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

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 ( )

overridedefault

Member Function Documentation

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.

References edm::HLTGlobalStatus::accept(), cms::cuda::assert(), edm::HLTGlobalStatus::at(), edm::InputTag::encode(), edm::Event::getByToken(), edm::Event::getRun(), patZpeak::handle, mps_fire::i, edm::Run::index(), edm::HandleBase::isValid(), or, fed_dqm_sourceclient-live_cfg::path, bookConverter::results, edm::HLTGlobalStatus::size(), 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() == 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];
}

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

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

static

Definition at line 141 of file HLTriggerJSONMonitoring.cc.

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

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

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

override

Definition at line 280 of file HLTriggerJSONMonitoring.cc.

References contentValuesFiles::datasets, edm::LuminosityBlock::getRun(), mps_fire::i, and edm::Run::index().

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

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.

References writedatasetfile::dataset, makeLayoutFileForGui::datasetNames, contentValuesFiles::datasets, mps_fire::i, edm::Service< T >::isAvailable(), dqmiolumiharvest::j, label, evf::MergeTypeJSNDATA, AlCaHLTBitMon_ParallelJobs::p, mergeAndRegister::paths, edm::InputTag::process(), edm::RunBase::run(), streamName_, AlCaHLTBitMon_QueryRunRegistry::string, L1TMuonDQMOffline_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!" << 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;
}

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

override

Definition at line 375 of file HLTriggerJSONMonitoring.cc.

References cms::Adler32(), Json::Value::append(), jsoncollector::DataPoint::DATA, HLTriggerJSONMonitoringData::lumisection::datasets, jsoncollector::DataPoint::DEFINITION, edm::LuminosityBlock::getRun(), HLTriggerJSONMonitoringData::lumisection::hltAccept, HLTriggerJSONMonitoringData::lumisection::hltErrors, HLTriggerJSONMonitoringData::lumisection::hltL1s, HLTriggerJSONMonitoringData::lumisection::hltPre, HLTriggerJSONMonitoringData::lumisection::hltReject, HLTriggerJSONMonitoringData::lumisection::hltWasRun, edm::Run::index(), eostools::ls(), edm::LuminosityBlockBase::luminosityBlock(), HLTriggerJSONMonitoringData::lumisection::processed, mps_fire::result, edm::LuminosityBlockBase::run(), submitPVValidationJobs::run, evf::FastMonitoringService::shouldWriteFiles(), jsoncollector::DataPoint::SOURCE, AlCaHLTBitMon_QueryRunRegistry::string, jsoncollector::HistoJ< T >::toJsonValue(), and jsoncollector::HistoJ< T >::value().

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

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

override

Definition at line 224 of file HLTriggerJSONMonitoring.cc.

{}

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

override

Definition at line 323 of file HLTriggerJSONMonitoring.cc.

References contentValuesFiles::datasets, edm::LuminosityBlock::getRun(), edm::Run::index(), 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.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);
}

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.

References contentValuesFiles::datasets, HLTriggerJSONMonitoringData::lumisection::datasets, edm::LuminosityBlock::getRun(), HLTriggerJSONMonitoringData::lumisection::hltAccept, HLTriggerJSONMonitoringData::lumisection::hltErrors, HLTriggerJSONMonitoringData::lumisection::hltL1s, HLTriggerJSONMonitoringData::lumisection::hltPre, HLTriggerJSONMonitoringData::lumisection::hltReject, HLTriggerJSONMonitoringData::lumisection::hltWasRun, mps_fire::i, edm::Run::index(), 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;

  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];
}

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

staticprivate

Definition at line 482 of file HLTriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

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

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

staticprivate

Definition at line 464 of file HLTriggerJSONMonitoring.cc.

References HLTriggerJSONMonitoringData::run::baseRunDir, mergeVDriftHistosByStation::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

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

staticprivate

Definition at line 125 of file HLTriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

const edm::InputTag HLTriggerJSONMonitoring::triggerResults_

private

Definition at line 131 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze(), and globalBeginRun().

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

private

Definition at line 132 of file HLTriggerJSONMonitoring.cc.

Referenced by analyze().

---

Generated for CMSSW Reference Manual by  1.8.5