TrigOpMonitor Class Reference

#include <TrigOpMonitor.h>

Inheritance diagram for TrigOpMonitor:

Collaboration diagram for TrigOpMonitor:

Classes
struct	FolderHist
	Histograms for COOL folders. More...

Public Member Functions
	TrigOpMonitor (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	execute () override
virtual void	handle (const Incident &incident) override
virtual unsigned int	cardinality () const override

Private Member Functions
void	fillMagFieldHist ()
void	fillReleaseDataHist ()
void	fillProcThreadHist (int workerID)
void	fillSubDetHist ()
void	fillIOVDbHist ()
void	fillIOVDbChangeHist (const EventContext &ctx)
void	fillLumiHist (const EventContext &ctx)
StatusCode	bookHists ()

Private Attributes
ServiceHandle< IIncidentSvc >	m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}
ServiceHandle< ITHistSvc >	m_histSvc {this, "THistSvc", "THistSvc"}
SmartIF< IIOVDbSvc >	m_IOVDbSvc
TH2I *	m_magFieldHist {nullptr}
TH2I *	m_iovChangeHist {nullptr}
TH1I *	m_releaseHist {nullptr}
TH2I *	m_mtConfigHist {nullptr}
TH1I *	m_workersHist {nullptr}
TH2I *	m_subdetHist {nullptr}
TProfile *	m_lumiHist {nullptr}
TProfile *	m_muHist {nullptr}
EventIDBase::number_type	m_previousLB {0}
	LB of previous event. More...
std::unordered_map< std::string, IOVRange >	m_currentIOVs
	current IOVs managed by IOVDbSvc More...
std::unordered_map< std::string, FolderHist >	m_folderHist
	histograms for COOL folders More...
std::string	m_histPath
	histogram booking path More...
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this, "LuminosityCondDataKey", ""}
SG::ReadCondHandleKey< AtlasFieldMapCondObj >	m_fieldMapKey {this, "AtlasFieldMapCondDataKey", ""}
Gaudi::Property< std::string >	m_releaseData
Gaudi::Property< bool >	m_detailedHists
Gaudi::Property< unsigned short int >	m_maxLB

Detailed Description

Definition at line 37 of file TrigOpMonitor.h.

Constructor & Destructor Documentation

TrigOpMonitor()

TrigOpMonitor::TrigOpMonitor	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 54 of file TrigOpMonitor.cxx.

                                                                            :
  base_class(name, pSvcLocator),
  m_histPath("/EXPERT/HLTFramework/" + name + "/")
{}

Member Function Documentation

bookHists()

StatusCode TrigOpMonitor::bookHists ( )

private

Definition at line 115 of file TrigOpMonitor.cxx.

{
  m_iovChangeHist = nullptr;
  m_currentIOVs.clear();
  m_folderHist.clear();
 
  m_iovChangeHist = new TH2I("CoolFolderUpdate_LB", "COOL folder updates;Lumiblock;", 1, 0, 1, 1, 0, 1);
 
  // create histogram for magnetic field information
  m_magFieldHist = new TH2I("MagneticFieldSettings", "Magnetic field settings", 2, 0, 2, 2, 0, 2);
  m_magFieldHist->GetYaxis()->SetBinLabel(1, "off");
  m_magFieldHist->GetYaxis()->SetBinLabel(2, "on");
  m_magFieldHist->GetXaxis()->SetBinLabel(1, "Solenoid");
  m_magFieldHist->GetXaxis()->SetBinLabel(2, "Toroid");
 
  m_releaseHist = new TH1I("GeneralOpInfo", "General operational info;;Applications", 1, 0, 1);
 
  m_mtConfigHist = new TH2I("MTConfig", "Multi-threading configuration", 2, 0, 2, 10, 0, 10);
  m_mtConfigHist->SetCanExtend(TH1::kYaxis);
  m_mtConfigHist->GetXaxis()->SetBinLabel(1, "N threads");
  m_mtConfigHist->GetXaxis()->SetBinLabel(2, "N slots");
 
  m_workersHist = new TH1I("MPWorkers", "Worker IDs;Worker ID;Number of workers", 10, 0, 10);
  m_workersHist->SetCanExtend(TH1::kXaxis);
 
  m_subdetHist = new TH2I("Subdetectors", "State of subdetectors", 1, 0, 1, 3, 0, 3);
  m_subdetHist->SetCanExtend(TH1::kXaxis);
  m_subdetHist->GetYaxis()->SetBinLabel(1, "# ROB");
  m_subdetHist->GetYaxis()->SetBinLabel(2, "off");
  m_subdetHist->GetYaxis()->SetBinLabel(3, "on");
 
  m_lumiHist = new TProfile("Luminosity", "Luminosity;Lumiblock;Luminosity [10^{33} cm^{-2}s^{-1}]",
                            m_maxLB, 0, m_maxLB);
 
  m_muHist = new TProfile("Pileup", "Pileup;Lumiblock;Interactions per BX", m_maxLB, 0, m_maxLB);
 
  // Register histograms
  TH1* hist[] = {
    m_releaseHist, m_mtConfigHist, m_workersHist, m_subdetHist,
    m_iovChangeHist, m_magFieldHist, m_lumiHist, m_muHist
  };
  for (TH1* h : hist) {
    if (h) ATH_CHECK(m_histSvc->regHist(m_histPath + h->GetName(), h));
  }
 
  return StatusCode::SUCCESS;
}

cardinality()

virtual unsigned int TrigOpMonitor::cardinality ( ) const

inlineoverridevirtual

Definition at line 49 of file TrigOpMonitor.h.

{ return 1; }

execute()

StatusCode TrigOpMonitor::execute ( )

overridevirtual

Definition at line 92 of file TrigOpMonitor.cxx.

{
  /* One-time fills */
  [[maybe_unused]] const static bool once = [&]() {
    fillMagFieldHist();
    return true;
  }();
 
  /* Per-LB fills */
  const EventContext& ctx = getContext();
  if (m_previousLB != ctx.eventID().lumi_block()) { // New LB
    m_previousLB = ctx.eventID().lumi_block();
 
    // Fill IOV diff histogram
    fillIOVDbChangeHist(ctx);
 
    // Fill lumi histogram
    fillLumiHist(ctx);
  }
 
  return StatusCode::SUCCESS;
}

fillIOVDbChangeHist()

void TrigOpMonitor::fillIOVDbChangeHist ( const EventContext &  ctx )

private

Definition at line 254 of file TrigOpMonitor.cxx.

{
  std::vector<std::string> keys;
  if (m_IOVDbSvc) keys = m_IOVDbSvc->getKeyList();
 
  // Loop over all keys known to IOVDbSvc
  IIOVDbSvc::KeyInfo info;
  for (const std::string& k : keys) {
    // cppcheck-suppress nullPointerRedundantCheck
    if (not m_IOVDbSvc->getKeyInfo(k, info)) continue;
    if (not info.retrieved) continue;
 
    const auto curIOV = m_currentIOVs.find(k);
    if (curIOV == m_currentIOVs.end()) {
      m_currentIOVs[k] = info.range;
      continue;
    }
 
    // Print IOV changes and fill histogram
    if (info.range != curIOV->second) {
      ATH_MSG_INFO("IOV of " << k << " changed from " << curIOV->second << " to " << info.range
                             << " on event: " << ctx.eventID());
 
      if (m_iovChangeHist) {
        // Perform a locked fill and remove any empty bins to allow correct gathering
        oh_scoped_lock_histogram lock;
        m_iovChangeHist->Fill(std::to_string(ctx.eventID().lumi_block()).c_str(), info.folderName.c_str(),
                              1);
        m_iovChangeHist->LabelsDeflate("X");
        m_iovChangeHist->LabelsDeflate("Y");
      }
 
      // Create detailed histograms per changed folder
      if (m_detailedHists) {
        auto fh = m_folderHist.find(info.folderName);
        if (fh == m_folderHist.end()) {
          std::string name(folder2HistName(info.folderName));
 
          fh = m_folderHist.insert({info.folderName, FolderHist()}).first;
          fh->second.h_time = new TH1F((name + "_ReadTime").c_str(),
                                       ("Update time for " + info.folderName + ";Time [ms];Entries").c_str(),
                                       100, 0, 200);
 
          fh->second.h_bytes = new TH1F(
              (name + "_BytesRead").c_str(),
              ("Bytes read for " + info.folderName + ";Data [bytes];Entries").c_str(), 100, 0, 1000);
 
          for (TH1* h : {fh->second.h_time, fh->second.h_bytes}) {
            m_histSvc->regHist(m_histPath + h->GetName(), h).ignore();
          }
        }
 
        // Need to plot the difference because IOVDbSvc reports total time and bytes for entire job
        fh->second.h_time->Fill(info.readTime * 1000 - m_folderHist[info.folderName].total_time);
        fh->second.total_time += info.readTime * 1000;
 
        fh->second.h_bytes->Fill(info.bytesRead - m_folderHist[info.folderName].total_bytes);
        fh->second.total_bytes += info.bytesRead;
      }
 
      m_currentIOVs[k] = info.range;
    }
  }
}

fillIOVDbHist()

void TrigOpMonitor::fillIOVDbHist ( )

private

Definition at line 174 of file TrigOpMonitor.cxx.

{
  // create and fill histogram for IOVDb entries
  std::vector<std::string> keyList;
  if (m_IOVDbSvc) keyList = m_IOVDbSvc->getKeyList();
 
  // set up histograms
  TH2I* IOVDbRunHist = new TH2I("IOVDbRunRange", "IOVDb Run Range", 1, 0, 1, 1, 0, 1);
  TH2I* IOVDbTimeHist = new TH2I("IOVDbTimeRange", "IOVDb Time Range", 1, 0, 1, 1, 0, 1);
  TProfile* IOVDbBytesReadHist = new TProfile("IOVDbBytesRead", "Folder data read", 1, 0, 1);
  IOVDbBytesReadHist->SetYTitle("Data read [bytes]");
  TProfile* IOVDbReadTimeHist = new TProfile("IOVDbReadTime", "Folder update time", 1, 0, 1);
  IOVDbReadTimeHist->SetYTitle("Update time [ms]");
 
  // fill histograms
  IIOVDbSvc::KeyInfo info;
  for (const std::string& key : keyList) {
    // cppcheck-suppress nullPointerRedundantCheck
    if (m_IOVDbSvc->getKeyInfo(key, info) && info.retrieved) {
 
      m_currentIOVs[key] = info.range;
 
      IOVTime start(info.range.start());
      IOVTime stop(info.range.stop());
 
      // fill start condition (run number)
      if (start.isRunEvent()) {
        IOVDbRunHist->Fill(std::to_string(start.run()).c_str(), info.folderName.c_str(), 1.0);
      }
 
      // fill start condition (timestamp)
      if (start.isTimestamp()) {
        IOVDbTimeHist->Fill(std::to_string(start.timestamp()).c_str(), info.folderName.c_str(), 1.0);
      }
 
      // fill stop condition (run number)
      if (stop.isRunEvent()) {
        if (stop.run() == IOVTime::MAXRUN) {
          IOVDbRunHist->Fill("infinity", info.folderName.c_str(), 1.0);
        }
        else {
          IOVDbRunHist->Fill(std::to_string(stop.run()).c_str(), info.folderName.c_str(), 1.0);
        }
      }
 
      // fill stop condition (timestamp)
      if (stop.isTimestamp()) {
        if (stop.timestamp() == IOVTime::MAXTIMESTAMP) {
          IOVDbTimeHist->Fill("infinity", info.folderName.c_str(), 1.0);
        }
        else {
          IOVDbTimeHist->Fill(std::to_string(stop.timestamp()).c_str(), info.folderName.c_str(), 1.0);
        }
      }
 
      // fill read bytes and time read
      IOVDbBytesReadHist->Fill(info.folderName.c_str(), info.bytesRead, 1.0);
      IOVDbReadTimeHist->Fill(info.folderName.c_str(), info.readTime * 1000, 1.0);
    }
  }
 
  // final configuration of histograms
  IOVDbRunHist->LabelsDeflate("X");
  IOVDbRunHist->LabelsDeflate("Y");
  IOVDbRunHist->GetYaxis()->LabelsOption("a");
 
  IOVDbTimeHist->LabelsDeflate("X");
  IOVDbTimeHist->LabelsDeflate("Y");
  IOVDbTimeHist->GetYaxis()->LabelsOption("a");
 
  IOVDbBytesReadHist->LabelsDeflate("X");
  IOVDbReadTimeHist->LabelsDeflate("X");
 
  // Register histograms
  TH1* hist[] = {IOVDbRunHist, IOVDbTimeHist, IOVDbBytesReadHist, IOVDbReadTimeHist};
  for (TH1* h : hist) {
    m_histSvc->regHist(m_histPath + h->GetName(), h).ignore();
  }
}

fillLumiHist()

void TrigOpMonitor::fillLumiHist ( const EventContext &  ctx )

private

Definition at line 319 of file TrigOpMonitor.cxx.

{
  if (!m_lumiDataKey.empty()) {
    SG::ReadCondHandle<LuminosityCondData> lumiData(m_lumiDataKey, ctx);
    m_lumiHist->Fill(ctx.eventID().lumi_block(), lumiData->lbAverageLuminosity());
    m_muHist->Fill(ctx.eventID().lumi_block(), lumiData->lbAverageInteractionsPerCrossing());
  }
}

fillMagFieldHist()

void TrigOpMonitor::fillMagFieldHist ( )

private

Definition at line 163 of file TrigOpMonitor.cxx.

{
  if (!m_fieldMapKey.empty()) {
    SG::ReadCondHandle<AtlasFieldMapCondObj> fieldMapHandle(m_fieldMapKey);
    const MagField::AtlasFieldMap* fieldMap = fieldMapHandle->fieldMap();
    // if there is no field map, the field is off
    m_magFieldHist->Fill("Solenoid", fieldMap && fieldMap->solenoidOn() ? "on" : "off", 1.0);
    m_magFieldHist->Fill("Toroid", fieldMap && fieldMap->toroidOn() ? "on" : "off", 1.0);
  }
}

fillProcThreadHist()

void TrigOpMonitor::fillProcThreadHist ( int  workerID )

private

Definition at line 366 of file TrigOpMonitor.cxx.

{
  m_workersHist->Fill(workerID, 1);
 
  auto getIntProp = [this](std::string_view name, const std::string& prop) -> std::optional<int> {
    IProperty* svc = serviceLocator()->service(name).as<IProperty>();
    if (svc == nullptr) return std::nullopt;
    try {
      return std::stoi(svc->getProperty(prop).toString());
    }
    catch (...) {
      return std::nullopt;
    }
  };
 
  const std::optional<int> numThreads = getIntProp("AvalancheSchedulerSvc","ThreadPoolSize");
  if (numThreads.has_value()) {
    m_mtConfigHist->Fill("N threads", numThreads.value(), 1.0);
  }
  else {
    ATH_MSG_WARNING("Could not retrieve the number of threads to fill the monitoring histogram");
  }
 
  const std::optional<int> numSlots = getIntProp("EventDataSvc","NSlots");
  if (numSlots.has_value()) {
    m_mtConfigHist->Fill("N slots", numSlots.value(), 1.0);
  }
  else {
    ATH_MSG_WARNING("Could not retrieve the number of slots to fill the monitoring histogram");
  }
}

fillReleaseDataHist()

void TrigOpMonitor::fillReleaseDataHist ( )

private

Definition at line 328 of file TrigOpMonitor.cxx.

{
  const char* ld_lib_path = getenv("LD_LIBRARY_PATH");
  if (ld_lib_path == nullptr) {
    ATH_MSG_WARNING("LD_LIBRARY_PATH is not defined. Will not fill release histogram.");
    return;
  }
 
  // Find all release metadata files
  std::list<DirSearchPath::path> file_list = DirSearchPath(ld_lib_path, ":").find_all(m_releaseData.value());
 
  if (file_list.empty()) {
    ATH_MSG_WARNING("Could not find release metadata file " << m_releaseData
                                                            << " in LD_LIBRARY_PATH");
    m_releaseHist->Fill("Release ?", 1);
    return;
  }
 
  for (const auto& f : file_list) {
    // Read metadata file
    std::map<std::string, std::string> result;
    if (readReleaseData(f.string(), result).isFailure()) {
      ATH_MSG_WARNING("Could not read release metadata from " << f);
      m_releaseHist->Fill("Release ?", 1);
      return;
    }
 
    // Check format
    if (result.find("project name") == result.end() || result.find("release") == result.end()) {
      ATH_MSG_WARNING("Invalid release metadata format in " << f);
      m_releaseHist->Fill("Release ?", 1);
      return;
    }
 
    m_releaseHist->Fill((result["project name"] + " " + result["release"]).c_str(), 1);
  }
}

fillSubDetHist()

void TrigOpMonitor::fillSubDetHist ( )

private

Definition at line 398 of file TrigOpMonitor.cxx.

{
  // Retrieve the enabled ROBs/SubDets list from DataFlowConfig which is a special object
  // used online to hold DF properties passed from TDAQ to HLT as run parameters
  auto jobOptionsSvc = service<Gaudi::Interfaces::IOptionsSvc>("JobOptionsSvc", /*createIf=*/ false);
  if (!jobOptionsSvc.isValid()) {
    ATH_MSG_WARNING("Could not retrieve JobOptionsSvc, will not fill SubDetectors histogram");
    return;
  }
 
  Gaudi::Property<std::vector<uint32_t>> enabledROBsProp("EnabledROBs",{});
  std::set<uint32_t> enabledROBs;
  if (enabledROBsProp.fromString(jobOptionsSvc->get("DataFlowConfig.DF_Enabled_ROB_IDs","[]")).isSuccess()) {
    enabledROBs.insert(enabledROBsProp.value().begin(), enabledROBsProp.value().end());
    ATH_MSG_DEBUG("Retrieved a list of " << enabledROBs.size()
                  << " ROBs from DataFlowConfig.DF_Enabled_ROB_IDs");
  }
  else {
    ATH_MSG_ERROR("Could not parse DataFlowConfig.DF_Enabled_ROB_IDs from JobOptionsSvc");
  }
 
  // Retrieve detector mask from detector store
  SmartIF<StoreGateSvc> inputMetaDataStore = service<StoreGateSvc>("InputMetaDataStore", /*createIf=*/ false);
  if (!inputMetaDataStore.isValid()) {
    ATH_MSG_WARNING("Could not retrieve InputMetaDataStore, will not fill SubDetectors histogram");
    return;
  }
  const ByteStreamMetadataContainer* metadatacont{nullptr};
  if (inputMetaDataStore->retrieve(metadatacont, "ByteStreamMetadata").isFailure()) {
    ATH_MSG_WARNING("Could not retrieve ByteStreamMetadata, will not fill SubDetectors histogram");
    return;
  }
 
  const ByteStreamMetadata* metadata = *(metadatacont->begin());
  uint64_t detMaskLeast = metadata->getDetectorMask();
  uint64_t detMaskMost = metadata->getDetectorMask2();
 
  // Decode subdetector masks
  std::vector<eformat::SubDetector> subDetOn;
  std::vector<eformat::SubDetector> subDetOff;
  std::vector<eformat::SubDetector> subDetAll;
  eformat::helper::DetectorMask(detMaskLeast, detMaskMost).sub_detectors(subDetOn);
  eformat::helper::DetectorMask(~detMaskLeast, ~detMaskMost).sub_detectors(subDetOff);
  eformat::helper::DetectorMask(~std::bitset<128>()).sub_detectors(subDetAll);
 
  // Add bins with labels for every subdetector name
  for (const eformat::SubDetector sd : subDetAll) {
    m_subdetHist->GetXaxis()->FindBin(eformat::helper::SubDetectorDictionary.string(sd).data());
  }
  m_subdetHist->LabelsDeflate("X");
 
  // Fill histogram with enabled subdetectors
  for (const eformat::SubDetector sd : subDetOn) {
    m_subdetHist->Fill(eformat::helper::SubDetectorDictionary.string(sd).data(), "on", 1.0);
  }
 
  // Fill histogram with disabled subdetectors
  for (const eformat::SubDetector sd : subDetOff) {
    m_subdetHist->Fill(eformat::helper::SubDetectorDictionary.string(sd).data(), "off", 1.0);
  }
 
  // Fill histogram with ROB counts
  for (const uint32_t robid : enabledROBs) {
    const std::string sdname = eformat::helper::SourceIdentifier(robid).human_detector();
    m_subdetHist->Fill(sdname.data(), "# ROB", 1.0);
  }
}

handle()

void TrigOpMonitor::handle ( const Incident &  incident )

overridevirtual

Definition at line 71 of file TrigOpMonitor.cxx.

                                                     {
  // One time fills after fork
  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) {
    if (!m_IOVDbSvc) m_IOVDbSvc = service("IOVDbSvc", /*createIf=*/false);
    fillIOVDbHist();
    fillSubDetHist();
    const AthenaInterprocess::UpdateAfterFork& updinc = dynamic_cast<const AthenaInterprocess::UpdateAfterFork&>(incident);
    fillProcThreadHist(updinc.workerID());
  }
}

initialize()

StatusCode TrigOpMonitor::initialize ( )

overridevirtual

Definition at line 59 of file TrigOpMonitor.cxx.

{
  ATH_CHECK(m_histSvc.retrieve());
  ATH_CHECK(m_lumiDataKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_fieldMapKey.initialize(SG::AllowEmpty));
 
  ATH_CHECK( m_incidentSvc.retrieve() );
  m_incidentSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
 
  return StatusCode::SUCCESS;
}

start()

StatusCode TrigOpMonitor::start ( )

overridevirtual

Definition at line 82 of file TrigOpMonitor.cxx.

{
  m_previousLB = 0;
  if (!m_IOVDbSvc) m_IOVDbSvc = service("IOVDbSvc", /*createIf=*/false);
  ATH_CHECK(bookHists());
 
  fillReleaseDataHist();
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_currentIOVs

std::unordered_map<std::string, IOVRange> TrigOpMonitor::m_currentIOVs

private

current IOVs managed by IOVDbSvc

Definition at line 85 of file TrigOpMonitor.h.

m_detailedHists

Gaudi::Property<bool> TrigOpMonitor::m_detailedHists

private

Initial value:

{this, "DetailedFolderHists", true,
                                        "Detailed histograms for COOL folder updates during run"}

Definition at line 97 of file TrigOpMonitor.h.

m_fieldMapKey

SG::ReadCondHandleKey<AtlasFieldMapCondObj> TrigOpMonitor::m_fieldMapKey {this, "AtlasFieldMapCondDataKey", ""}

private

Definition at line 91 of file TrigOpMonitor.h.

m_folderHist

std::unordered_map<std::string, FolderHist> TrigOpMonitor::m_folderHist

private

histograms for COOL folders

Definition at line 86 of file TrigOpMonitor.h.

m_histPath

std::string TrigOpMonitor::m_histPath

private

histogram booking path

Definition at line 87 of file TrigOpMonitor.h.

m_histSvc

ServiceHandle<ITHistSvc> TrigOpMonitor::m_histSvc {this, "THistSvc", "THistSvc"}

private

Definition at line 71 of file TrigOpMonitor.h.

m_incidentSvc

ServiceHandle<IIncidentSvc> TrigOpMonitor::m_incidentSvc { this, "IncidentSvc", "IncidentSvc", "Incident service"}

private

Definition at line 70 of file TrigOpMonitor.h.

m_iovChangeHist

TH2I* TrigOpMonitor::m_iovChangeHist {nullptr}

private

Definition at line 76 of file TrigOpMonitor.h.

m_IOVDbSvc

SmartIF<IIOVDbSvc> TrigOpMonitor::m_IOVDbSvc

private

Definition at line 73 of file TrigOpMonitor.h.

m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> TrigOpMonitor::m_lumiDataKey {this, "LuminosityCondDataKey", ""}

private

Definition at line 90 of file TrigOpMonitor.h.

m_lumiHist

TProfile* TrigOpMonitor::m_lumiHist {nullptr}

private

Definition at line 81 of file TrigOpMonitor.h.

m_magFieldHist

TH2I* TrigOpMonitor::m_magFieldHist {nullptr}

private

Definition at line 75 of file TrigOpMonitor.h.

m_maxLB

Gaudi::Property<unsigned short int> TrigOpMonitor::m_maxLB

private

Initial value:

{this, "MaxLumiblocks", 3000,
                                              "Number of lumiblocks for histograms"}

Definition at line 100 of file TrigOpMonitor.h.

m_mtConfigHist

TH2I* TrigOpMonitor::m_mtConfigHist {nullptr}

private

Definition at line 78 of file TrigOpMonitor.h.

m_muHist

TProfile* TrigOpMonitor::m_muHist {nullptr}

private

Definition at line 82 of file TrigOpMonitor.h.

m_previousLB

EventIDBase::number_type TrigOpMonitor::m_previousLB {0}

private

LB of previous event.

Definition at line 84 of file TrigOpMonitor.h.

m_releaseData

Gaudi::Property<std::string> TrigOpMonitor::m_releaseData

private

Initial value:

{
      this, "ReleaseDataFile", "../ReleaseData",
      "Path to ReleaseData file (relative to LD_LIBRARY_PATH entries"}

Definition at line 93 of file TrigOpMonitor.h.

m_releaseHist

TH1I* TrigOpMonitor::m_releaseHist {nullptr}

private

Definition at line 77 of file TrigOpMonitor.h.

m_subdetHist

TH2I* TrigOpMonitor::m_subdetHist {nullptr}

private

Definition at line 80 of file TrigOpMonitor.h.

m_workersHist

TH1I* TrigOpMonitor::m_workersHist {nullptr}

private

Definition at line 79 of file TrigOpMonitor.h.

---

The documentation for this class was generated from the following files:

• TrigOpMonitor.h
• TrigOpMonitor.cxx