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
Public Member Functions inherited from edm::global::EDAnalyzerBase
	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
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::vector< ModuleDescription const * > &modules, 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	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
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 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)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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

Definition at line 75 of file HLTriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

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

explicit

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

References edm::HLTGlobalStatus::accept(), edm::HLTGlobalStatus::at(), edm::InputTag::encode(), edm::Event::getByToken(), edm::Event::getRun(), cmsBatch::handle, mps_fire::i, edm::Run::index(), diffTreeTool::index, createfilelist::int, edm::HandleBase::isValid(), or, callgraph::path, mps_update::results, lumiPlot::rundata, edm::HLTGlobalStatus::size(), mps_update::status, 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 155 of file HLTriggerJSONMonitoring.cc.

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

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

static

Definition at line 146 of file HLTriggerJSONMonitoring.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

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

References edmIntegrityCheck::datasets, edm::LuminosityBlock::getRun(), mps_fire::i, edm::Run::index(), tablePrinter::lumidata, and lumiPlot::rundata.

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

References makeLayoutFileForGui::datasetNames, edmIntegrityCheck::datasets, cmsPerfStripChart::format, mps_fire::i, diffTreeTool::index, edm::Service< T >::isAvailable(), diffTwoXMLs::label, evf::MergeTypeJSNDATA, AlCaHLTBitMon_ParallelJobs::p, edm::InputTag::process(), edm::RunBase::run(), lumiPlot::rundata, harvestTrackValidationPlots::str, streamName_, AlCaHLTBitMon_QueryRunRegistry::string, 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 = (boost::format("run%06d_ls0000_streamHLTRates_pid%05d.jsd") % run.run() % getpid()).str();
  writeJsdFile(*rundata);

  // write the per-run .ini file
  // iniFileName = (boost::format("run%06d_ls0000_streamHLTRates_pid%05d.ini") % run.run() % getpid()).str();
  writeIniFile(*rundata, run.run());

  return rundata;
}

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

override

Definition at line 379 of file HLTriggerJSONMonitoring.cc.

References cms::Adler32(), Json::Value::append(), jsoncollector::DataPoint::DATA, HLTriggerJSONMonitoringData::lumisection::datasets, jsoncollector::DataPoint::DEFINITION, cmsPerfStripChart::format, 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(), findQualityFiles::run, lumiPlot::rundata, evf::FastMonitoringService::shouldWriteFiles(), jsoncollector::DataPoint::SOURCE, AlCaHLTBitMon_QueryRunRegistry::string, jsoncollector::HistoJ< T >::toJsonValue(), jsoncollector::HistoJ< T >::value(), and cscNeutronWriter_cfi::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->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 = boost::format("run%06d_ls%04d_streamHLTRates_pid%05d.jsndata") % run % ls % getpid();

    std::string result = writer.write(jsndata);
    std::ofstream jsndataFile(rundata.baseRunDir + "/" + jsndataFileName.str());
    jsndataFile << result;
    jsndataFile.close();

    jsndataFileList = jsndataFileName.str();
    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 = boost::format("run%06d_ls%04d_streamHLTRates_pid%05d.jsn") % run % ls % getpid();
  std::ofstream jsnFile( rundata.baseRunDir + "/" + jsnFileName.str() );
  jsnFile << writer.write(jsn);
  jsnFile.close();
}

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

override

Definition at line 233 of file HLTriggerJSONMonitoring.cc.

{
}

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

override

Definition at line 328 of file HLTriggerJSONMonitoring.cc.

References edmIntegrityCheck::datasets, edm::LuminosityBlock::getRun(), edm::Run::index(), and lumiPlot::rundata.

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

References edmIntegrityCheck::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, lumiPlot::rundata, 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 487 of file HLTriggerJSONMonitoring.cc.

References Json::Value::append(), Json::arrayValue, HLTriggerJSONMonitoringData::run::baseRunDir, ws_sso_content_reader::content, makeLayoutFileForGui::datasetNames, HLTConfigProvider::datasetNames(), DEFINE_FWK_MODULE, FrontierConditions_GlobalTag_cff::file, cmsPerfStripChart::format, HLTriggerJSONMonitoringData::run::hltConfig, dataset::name, harvestTrackValidationPlots::str, AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerNames(), Json::StyledWriter::write(), and cscNeutronWriter_cfi::writer.

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 = (boost::format("run%06d_ls0000_streamHLTRates_pid%05d.ini") % run % getpid()).str();
  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 467 of file HLTriggerJSONMonitoring.cc.

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

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