L1TriggerJSONMonitoring Class Reference

Inheritance diagram for L1TriggerJSONMonitoring:

Public Member Functions
void	analyze (edm::StreamID, edm::Event const &, edm::EventSetup const &) const override
std::unique_ptr< L1TriggerJSONMonitoringData::stream >	beginStream (edm::StreamID) const override
std::shared_ptr< L1TriggerJSONMonitoringData::lumisection >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &) const override
std::shared_ptr< L1TriggerJSONMonitoringData::run >	globalBeginRun (edm::Run const &, edm::EventSetup const &) const override
void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, L1TriggerJSONMonitoringData::lumisection *) const override
void	globalEndRun (edm::Run const &, edm::EventSetup const &) const override
	L1TriggerJSONMonitoring (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 &, L1TriggerJSONMonitoringData::lumisection *) const override
	~L1TriggerJSONMonitoring () override=default
Public Member Functions inherited from edm::global::EDAnalyzer< edm::StreamCache< L1TriggerJSONMonitoringData::stream >, edm::RunCache< L1TriggerJSONMonitoringData::run >, edm::LuminosityBlockSummaryCache< L1TriggerJSONMonitoringData::lumisection > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::global::EDAnalyzerBase
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
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 (L1TriggerJSONMonitoringData::run const &, unsigned int, std::vector< std::string > const &)
static void	writeJsdFile (L1TriggerJSONMonitoringData::run const &)

Private Attributes
const edm::InputTag	level1Results_
const edm::EDGetTokenT< GlobalAlgBlkBxCollection >	level1ResultsToken_

Static Private Attributes
static const int	kPrescaleConflict = -1
static const int	kPrescaleUndefined = -2
static const char *	streamName_ = "streamL1Rates"
static const std::array< const char *, 16 >	tcdsTriggerTypes_

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 TCDS and L1T monitoring information.

Definition at line 71 of file L1TriggerJSONMonitoring.cc.

Constructor & Destructor Documentation

L1TriggerJSONMonitoring::L1TriggerJSONMonitoring ( const edm::ParameterSet &  )

explicit

Definition at line 162 of file L1TriggerJSONMonitoring.cc.

                                                                              :
  level1Results_(config.getParameter<edm::InputTag>("L1Results")),
  level1ResultsToken_(consumes<GlobalAlgBlkBxCollection>(level1Results_))
{
}

L1TriggerJSONMonitoring::~L1TriggerJSONMonitoring ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements edm::global::EDAnalyzerBase.

Definition at line 231 of file L1TriggerJSONMonitoring.cc.

References BXVector< T >::at(), edm::EventAuxiliary::CalibrationTrigger, edm::InputTag::encode(), edm::Event::getByToken(), cmsBatch::handle, mps_fire::i, edm::HandleBase::isValid(), kPrescaleConflict, kPrescaleUndefined, level1Results_, level1ResultsToken_, GlobalAlgBlk::maxPhysicsTriggers, or, edm::EventAuxiliary::PhysicsTrigger, edm::EventAuxiliary::RandomTrigger, mps_update::results, and tcdsTriggerTypes_.

{
  auto & stream = * streamCache(sid);

  ++stream.processed;
  unsigned int eventType = event.experimentType();
  if (eventType < tcdsTriggerTypes_.size())
    ++stream.tcdsAccept[eventType];
  else
    edm::LogWarning("L1TriggerJSONMonitoring") << "Unexpected event type " << eventType;

  // get hold of TriggerResults
  edm::Handle<GlobalAlgBlkBxCollection> handle;
  if (not event.getByToken(level1ResultsToken_, handle) or not handle.isValid()){
    edm::LogError("L1TriggerJSONMonitoring") << "L1 trigger results with label [" + level1Results_.encode() + "] not present or invalid";
    return;
  }

  // The GlobalAlgBlkBxCollection is a vector of vectors, but the second layer can only ever
  // have one entry since there can't be more than one collection per bunch crossing.
  // The first "0" here means BX = 0, while the second "0" is used to access the first and only element.
  auto const& results = handle->at(0, 0);
  auto const& decision = results.getAlgoDecisionFinal();
  assert (decision.size() == GlobalAlgBlk::maxPhysicsTriggers);

  // check the results for each HLT path
  for (unsigned int i = 0; i < decision.size(); ++i) {
    if (decision[i]) {
      ++stream.l1tAccept[i];
      switch (eventType) {
      case edm::EventAuxiliary::PhysicsTrigger:
        ++stream.l1tAcceptPhysics[i];
        break;
      case edm::EventAuxiliary::CalibrationTrigger:
        ++stream.l1tAcceptCalibration[i];
        break;
      case edm::EventAuxiliary::RandomTrigger:
        ++stream.l1tAcceptRandom[i];
        break;
      default:
        break;
      }
    }
  }

  // check for conflicting values in the prescale column index, and store it
  int prescaleIndex = results.getPreScColumn();
  if (stream.prescaleIndex == kPrescaleUndefined) {
    stream.prescaleIndex = prescaleIndex;
  } else if (stream.prescaleIndex == kPrescaleConflict) {
    // do nothing
  } else if (stream.prescaleIndex != prescaleIndex) {
    edm::LogWarning("L1TriggerJSONMonitoring") <<
      "Prescale index changed from " << stream.prescaleIndex << " to " << prescaleIndex << " inside lumisection " << event.luminosityBlock();
    stream.prescaleIndex = kPrescaleConflict;
  }
}

std::unique_ptr< L1TriggerJSONMonitoringData::stream > L1TriggerJSONMonitoring::beginStream ( edm::StreamID  ) const

override

Definition at line 179 of file L1TriggerJSONMonitoring.cc.

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

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

static

Definition at line 170 of file L1TriggerJSONMonitoring.cc.

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

{
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("L1Results",edm::InputTag("hltGtStage2Digis"));
  descriptions.add("L1TriggerJSONMonitoring", desc);
}

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

override

Definition at line 292 of file L1TriggerJSONMonitoring.cc.

References mps_fire::i, kPrescaleUndefined, tablePrinter::lumidata, GlobalAlgBlk::maxPhysicsTriggers, and tcdsTriggerTypes_.

{
  // 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<L1TriggerJSONMonitoringData::lumisection>(L1TriggerJSONMonitoringData::lumisection{
    jsoncollector::HistoJ<unsigned int>(1),                                     // processed
    jsoncollector::HistoJ<unsigned int>(GlobalAlgBlk::maxPhysicsTriggers),      // l1tAccept
    jsoncollector::HistoJ<unsigned int>(GlobalAlgBlk::maxPhysicsTriggers),      // l1tAcceptPhysics
    jsoncollector::HistoJ<unsigned int>(GlobalAlgBlk::maxPhysicsTriggers),      // l1tAcceptCalibration
    jsoncollector::HistoJ<unsigned int>(GlobalAlgBlk::maxPhysicsTriggers),      // l1tAcceptRandom
    jsoncollector::HistoJ<unsigned int>(tcdsTriggerTypes_.size())               // tcdsAccept
  });
  // repeated calls to `update` necessary to set the internal element counter
  lumidata->processed.update(0);
  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) lumidata->l1tAccept.update(0);
  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) lumidata->l1tAcceptPhysics.update(0);
  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) lumidata->l1tAcceptCalibration.update(0);
  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) lumidata->l1tAcceptRandom.update(0);
  for (unsigned int i = 0; i < tcdsTriggerTypes_.size(); ++i)         lumidata->tcdsAccept.update(0);
  lumidata->prescaleIndex = kPrescaleUndefined;

  return lumidata;
}

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

override

Definition at line 186 of file L1TriggerJSONMonitoring.cc.

References patPFMETCorrections_cff::algo, cmsPerfStripChart::format, edm::EventSetup::get(), L1TUtmTriggerMenu::getAlgorithmMap(), edm::Service< T >::isAvailable(), edm::ESHandleBase::isValid(), GlobalAlgBlk::maxPhysicsTriggers, evf::MergeTypeJSNDATA, edm::RunBase::run(), lumiPlot::rundata, alignCSCRings::s, harvestTrackValidationPlots::str, streamName_, writeIniFile(), and writeJsdFile().

{
  auto rundata = std::make_shared<L1TriggerJSONMonitoringData::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        = ".";
  }

  // read the L1 trigger names from the EventSetup
  std::vector<std::string> triggerNames(GlobalAlgBlk::maxPhysicsTriggers, ""s);
  edm::ESHandle<L1TUtmTriggerMenu> menuHandle;
  setup.get<L1TUtmTriggerMenuRcd>().get(menuHandle);
  if (menuHandle.isValid()) {
    for (auto const& algo: menuHandle->getAlgorithmMap())
      triggerNames[algo.second.getIndex()] = algo.first;
  } else {
    edm::LogWarning("L1TriggerJSONMonitoring") << "L1TUtmTriggerMenu not found in the EventSetup.\nThe Level 1 Trigger rate monitoring will not include the trigger names.";
  }

  // write the per-run .jsd file
  rundata->jsdFileName = (boost::format("run%06d_ls0000_streamL1Rates_pid%05d.jsd") % run.run() % getpid()).str();
  writeJsdFile(*rundata);

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

  return rundata;
}

void L1TriggerJSONMonitoring::globalEndLuminosityBlockSummary ( edm::LuminosityBlock const &  lumi, edm::EventSetup const &  , L1TriggerJSONMonitoringData::lumisection *  lumidata  ) const

override

Definition at line 357 of file L1TriggerJSONMonitoring.cc.

References cms::Adler32(), Json::Value::append(), edm::EventAuxiliary::CalibrationTrigger, jsoncollector::DataPoint::DATA, jsoncollector::DataPoint::DEFINITION, cmsPerfStripChart::format, edm::LuminosityBlock::getRun(), edm::Run::index(), L1TriggerJSONMonitoringData::lumisection::l1tAccept, L1TriggerJSONMonitoringData::lumisection::l1tAcceptCalibration, L1TriggerJSONMonitoringData::lumisection::l1tAcceptPhysics, L1TriggerJSONMonitoringData::lumisection::l1tAcceptRandom, eostools::ls(), edm::LuminosityBlockBase::luminosityBlock(), edm::EventAuxiliary::PhysicsTrigger, L1TriggerJSONMonitoringData::lumisection::prescaleIndex, L1TriggerJSONMonitoringData::lumisection::processed, edm::EventAuxiliary::RandomTrigger, mps_fire::result, edm::LuminosityBlockBase::run(), findQualityFiles::run, lumiPlot::rundata, evf::FastMonitoringService::shouldWriteFiles(), jsoncollector::DataPoint::SOURCE, AlCaHLTBitMon_QueryRunRegistry::string, L1TriggerJSONMonitoringData::lumisection::tcdsAccept, jsoncollector::HistoJ< T >::toJsonValue(), jsoncollector::HistoJ< T >::update(), 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->l1tAccept.toJsonValue());
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->l1tAcceptPhysics.toJsonValue());
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->l1tAcceptCalibration.toJsonValue());
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->l1tAcceptRandom.toJsonValue());

    // write only the number of "physics", "calibration" and "random" events
    jsoncollector::HistoJ<unsigned int> tcdsAccept;
    tcdsAccept.update(lumidata->tcdsAccept.value()[edm::EventAuxiliary::PhysicsTrigger]);
    tcdsAccept.update(lumidata->tcdsAccept.value()[edm::EventAuxiliary::CalibrationTrigger]);
    tcdsAccept.update(lumidata->tcdsAccept.value()[edm::EventAuxiliary::RandomTrigger]);
    jsndata[jsoncollector::DataPoint::DATA].append(tcdsAccept.toJsonValue());
    /* FIXME send information for all event types instead of only these three
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->tcdsAccept.toJsonValue());
    */
    jsndata[jsoncollector::DataPoint::DATA].append(lumidata->prescaleIndex);

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

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

override

Definition at line 225 of file L1TriggerJSONMonitoring.cc.

{
}

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

override

Definition at line 318 of file L1TriggerJSONMonitoring.cc.

References kPrescaleUndefined, GlobalAlgBlk::maxPhysicsTriggers, and tcdsTriggerTypes_.

{
  auto & stream = * streamCache(sid);

  // reset the stream counters
  stream.processed = 0;
  stream.l1tAccept.assign(GlobalAlgBlk::maxPhysicsTriggers, 0);
  stream.l1tAcceptPhysics.assign(GlobalAlgBlk::maxPhysicsTriggers, 0);
  stream.l1tAcceptCalibration.assign(GlobalAlgBlk::maxPhysicsTriggers, 0);
  stream.l1tAcceptRandom.assign(GlobalAlgBlk::maxPhysicsTriggers, 0);
  stream.tcdsAccept.assign(tcdsTriggerTypes_.size(), 0);
  stream.prescaleIndex = kPrescaleUndefined;
}

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

override

Definition at line 334 of file L1TriggerJSONMonitoring.cc.

References mps_fire::i, kPrescaleConflict, kPrescaleUndefined, L1TriggerJSONMonitoringData::lumisection::l1tAccept, L1TriggerJSONMonitoringData::lumisection::l1tAcceptCalibration, L1TriggerJSONMonitoringData::lumisection::l1tAcceptPhysics, L1TriggerJSONMonitoringData::lumisection::l1tAcceptRandom, GlobalAlgBlk::maxPhysicsTriggers, L1TriggerJSONMonitoringData::lumisection::prescaleIndex, L1TriggerJSONMonitoringData::lumisection::processed, L1TriggerJSONMonitoringData::lumisection::tcdsAccept, tcdsTriggerTypes_, and jsoncollector::HistoJ< T >::value().

{
  auto const& stream  = * streamCache(sid);
  lumidata->processed.value()[0] += stream.processed;

  for (unsigned int i = 0; i < GlobalAlgBlk::maxPhysicsTriggers; ++i) {
    lumidata->l1tAccept.value()[i] += stream.l1tAccept[i];
    lumidata->l1tAcceptPhysics.value()[i] += stream.l1tAcceptPhysics[i];
    lumidata->l1tAcceptCalibration.value()[i] += stream.l1tAcceptCalibration[i];
    lumidata->l1tAcceptRandom.value()[i] += stream.l1tAcceptRandom[i];
  }
  for (unsigned int i = 0; i < tcdsTriggerTypes_.size(); ++i)
    lumidata->tcdsAccept.value()[i] += stream.tcdsAccept[i];

  // check for conflicting values in the prescale column index
  if (lumidata->prescaleIndex == kPrescaleUndefined)
    lumidata->prescaleIndex = stream.prescaleIndex;
  else if (lumidata->prescaleIndex != stream.prescaleIndex)
    lumidata->prescaleIndex = kPrescaleConflict;
}

void L1TriggerJSONMonitoring::writeIniFile ( L1TriggerJSONMonitoringData::run const &  rundata, unsigned int  run, std::vector< std::string > const &  l1TriggerNames  )

staticprivate

Definition at line 470 of file L1TriggerJSONMonitoring.cc.

References Json::Value::append(), Json::arrayValue, L1TriggerJSONMonitoringData::run::baseRunDir, edm::EventAuxiliary::CalibrationTrigger, ws_sso_content_reader::content, DEFINE_FWK_MODULE, FrontierConditions_GlobalTag_cff::file, cmsPerfStripChart::format, dataset::name, edm::EventAuxiliary::PhysicsTrigger, edm::EventAuxiliary::RandomTrigger, harvestTrackValidationPlots::str, AlCaHLTBitMon_QueryRunRegistry::string, tcdsTriggerTypes_, Json::StyledWriter::write(), and cscNeutronWriter_cfi::writer.

Referenced by globalBeginRun().

{
  Json::Value content;

  Json::Value triggerNames(Json::arrayValue);
  for (auto const& name: l1TriggerNames)
    triggerNames.append(name);
  content["L1-Algo-Names"] = triggerNames;

  Json::Value eventTypes(Json::arrayValue);
  eventTypes.append(tcdsTriggerTypes_[edm::EventAuxiliary::PhysicsTrigger]);
  eventTypes.append(tcdsTriggerTypes_[edm::EventAuxiliary::CalibrationTrigger]);
  eventTypes.append(tcdsTriggerTypes_[edm::EventAuxiliary::RandomTrigger]);
  /* FIXME send information for all event types instead of only these three
  for (auto const& name : tcdsTriggerTypes_)
    eventTypes.append(name);
  */
  content["Event-Type"] = eventTypes;

  std::string iniFileName = (boost::format("run%06d_ls0000_streamL1Rates_pid%05d.ini") % run % getpid()).str();
  std::ofstream file(rundata.baseRunDir + "/" + iniFileName);
  Json::StyledWriter writer;
  file << writer.write(content);
  file.close();
}

void L1TriggerJSONMonitoring::writeJsdFile ( L1TriggerJSONMonitoringData::run const &  rundata )

staticprivate

Definition at line 452 of file L1TriggerJSONMonitoring.cc.

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

Referenced by globalBeginRun().

{
  std::ofstream file(rundata.baseRunDir + "/" + rundata.jsdFileName);
  file << R"""({
   "data" : [
      { "name" : "Processed", "type" : "integer", "operation" : "histo"},
      { "name" : "L1-AlgoAccepted", "type" : "integer", "operation" : "histo"},
      { "name" : "L1-AlgoAccepted-Physics", "type" : "integer", "operation" : "histo"},
      { "name" : "L1-AlgoAccepted-Calibration", "type" : "integer", "operation" : "histo"},
      { "name" : "L1-AlgoAccepted-Random", "type" : "integer", "operation" : "histo"},
      { "name" : "L1-Global", "type" : "integer", "operation" : "histo"},
      { "name" : "Prescale-Index", "type" : "integer", "operation" : "sample"}
   ]
})""";
  file.close();
}

Member Data Documentation

const int L1TriggerJSONMonitoring::kPrescaleConflict = -1

staticprivate

Definition at line 145 of file L1TriggerJSONMonitoring.cc.

Referenced by analyze(), and streamEndLuminosityBlockSummary().

const int L1TriggerJSONMonitoring::kPrescaleUndefined = -2

staticprivate

Definition at line 144 of file L1TriggerJSONMonitoring.cc.

Referenced by analyze(), globalBeginLuminosityBlockSummary(), streamBeginLuminosityBlock(), and streamEndLuminosityBlockSummary().

const edm::InputTag L1TriggerJSONMonitoring::level1Results_

private

Definition at line 153 of file L1TriggerJSONMonitoring.cc.

Referenced by analyze().

const edm::EDGetTokenT<GlobalAlgBlkBxCollection> L1TriggerJSONMonitoring::level1ResultsToken_

private

Definition at line 154 of file L1TriggerJSONMonitoring.cc.

Referenced by analyze().

const char* L1TriggerJSONMonitoring::streamName_ = "streamL1Rates"

staticprivate

Definition at line 147 of file L1TriggerJSONMonitoring.cc.

Referenced by globalBeginRun().

const std::array< const char *, 16 > L1TriggerJSONMonitoring::tcdsTriggerTypes_

staticprivate

Initial value:

= {{
    "Error",           
    "Physics",         
    "Calibration",     
    "Random",          
    "Auxiliary",       
    "",                
    "",                
    "",                
    "Cyclic",          
    "Bunch-pattern",   
    "Software",        
    "TTS",             
    "",                
    "",                
    "",                
    ""                 
  }}

Definition at line 124 of file L1TriggerJSONMonitoring.cc.

Referenced by analyze(), globalBeginLuminosityBlockSummary(), streamBeginLuminosityBlock(), streamEndLuminosityBlockSummary(), and writeIniFile().