Implementation of IHistogramProvider for offline histograms. More...

#include <OfflineHistogramProvider.h>

Inheritance diagram for Monitored::OfflineHistogramProvider:

Collaboration diagram for Monitored::OfflineHistogramProvider:

Classes
struct	objcache

Public Member Functions
	OfflineHistogramProvider (GenericMonitoringTool *const gmTool, std::shared_ptr< HistogramFactory > factory, const HistogramDef &histDef)
	Constructor.
virtual	~OfflineHistogramProvider () override
TNamed *	histogram () override
	Getter of ROOT object.

Private Member Functions
void	storeMetadata ()
	Store metadata trees.

Private Attributes
GenericMonitoringTool *const	m_gmTool
std::shared_ptr< HistogramFactory >	m_factory
std::shared_ptr< HistogramDef >	m_histDef
Gaudi::Hive::ContextSpecificData< objcache > m_objcache	ATLAS_THREAD_SAFE
std::mutex	m_cacheMutex
std::vector< std::string >	m_storedPaths

Detailed Description

Implementation of IHistogramProvider for offline histograms.

Definition at line 29 of file OfflineHistogramProvider.h.

Constructor & Destructor Documentation

◆ OfflineHistogramProvider()

Monitored::OfflineHistogramProvider::OfflineHistogramProvider	(	GenericMonitoringTool *const	gmTool,
		std::shared_ptr< HistogramFactory >	factory,
		const HistogramDef &	histDef )

inline

Constructor.

Parameters

gmTool	Source of the lumi block info
factory	ROOT object factory
def	General definition of a histogram

Definition at line 38 of file OfflineHistogramProvider.h.

    : IHistogramProvider()
    , m_gmTool(gmTool)
    , m_factory(std::move(factory))
    , m_histDef(new HistogramDef(histDef))
    , m_objcache({0, 0, nullptr})
    {}

◆ ~OfflineHistogramProvider()

virtual Monitored::OfflineHistogramProvider::~OfflineHistogramProvider ( )

inlineoverridevirtual

Definition at line 49 of file OfflineHistogramProvider.h.

                                                 {
      try {
        storeMetadata();
      }
      catch (const GaudiException&) {
        // storeMetadata can throw due to dereferencing a Gaudi handle
        std::abort();
      }
    }

Member Function Documentation

◆ histogram()

TNamed * Monitored::OfflineHistogramProvider::histogram ( )

inlineoverridevirtual

Getter of ROOT object.

Each time the method is called, factory produces ROOT object based on the current lumi block. Note: ROOT objects are cached at the factory. Nevertheless, it is recommended to call this method as rarely as possible.

Returns: ROOT object

Implements Monitored::IHistogramProvider.

Definition at line 68 of file OfflineHistogramProvider.h.

                                 {
      const unsigned runNumber = m_gmTool->runNumber();
      const unsigned lumiBlock = m_gmTool->lumiBlock();
 
      // do we have the object already?
      std::scoped_lock lock(m_cacheMutex);
      objcache& objcacheref = m_objcache;
      if (objcacheref.lumiBlock == lumiBlock
            && objcacheref.runNumber == runNumber
            && objcacheref.object) {
          return objcacheref.object;
      }
 
      std::string lbString;
      HistogramDef::RunPeriod period = m_histDef->runperiod;
      if ( period == HistogramDef::RunPeriod::Run ) {
        lbString = "";
      } else if ( period == HistogramDef::RunPeriod::LowStat ) {
        const unsigned lbBase = lumiBlock-(((int64_t)lumiBlock-1)%20);
        lbString = "/lowStat_LB"+std::to_string(lbBase)+"-"+std::to_string(lbBase+19);
      } else {
        lbString = "/lb_"+std::to_string(lumiBlock);
      }
      m_histDef->tld = "/run_"+std::to_string(runNumber)+lbString+"/";
 
      objcacheref.lumiBlock = lumiBlock;
      objcacheref.runNumber = runNumber;
      objcacheref.object = m_factory->create(*m_histDef);
      const auto fullName = m_factory->getFullName(*m_histDef);
      if (std::find(m_storedPaths.begin(), m_storedPaths.end(), fullName) == m_storedPaths.end()) {
        m_storedPaths.push_back(std::move(fullName));
      }
      return objcacheref.object;
    }

◆ storeMetadata()

void Monitored::OfflineHistogramProvider::storeMetadata ( )

inlineprivate

Store metadata trees.

Offline ROOT output should have "metadata" TTrees; this function makes them

Definition at line 124 of file OfflineHistogramProvider.h.

                         {
      std::scoped_lock<std::mutex> metadataLock(s_metadataMutex);
      auto &histSvc = m_gmTool->histogramService();
      for (const auto &path : m_storedPaths) {
        //std::cout << "Path " << path << std::endl;
        size_t pos = path.find_last_of('/');
        auto splitPath = std::make_pair(path.substr(0, pos), path.substr(pos + 1));
        std::string treePath = splitPath.first + "/metadata";
        std::string interval;
        char triggerData[] = "<none>";
        const std::string mergeDataStr = m_histDef->merge == "" ? "<default>" : m_histDef->merge;
        std::vector<char> mergeData{mergeDataStr.begin(), mergeDataStr.end()};
        mergeData.push_back('\0');
 
        HistogramDef::RunPeriod period = m_histDef->runperiod;
        if (period == HistogramDef::RunPeriod::Run) {
          interval = "run";
        } else if (period == HistogramDef::RunPeriod::LowStat) {
          interval = "lowStat";
        } else {
          interval = "lumiBlock";
        }
        if (!histSvc->existsTree(treePath)) {
          auto tree = std::make_unique<TTree>("metadata", "Monitoring Metadata");
 
          tree->Branch("Name", &(splitPath.second[0]), "Name/C");
          tree->Branch("Interval", &(interval[0]), "Interval/C");
          tree->Branch("TriggerChain", triggerData, "TriggerChain/C");
          tree->Branch("MergeMethod", mergeData.data(), "MergeMethod/C");
          tree->Fill();
 
          if (!histSvc->regTree(treePath, std::move(tree))) {
            MsgStream log(Athena::getMessageSvc(), "OfflineHistogramProvider");
            log << MSG::ERROR
                << "Failed to register DQ metadata TTree " << treePath << endmsg;
          }
        } else {
          TTree *tree{nullptr};
          if (histSvc->getTree(treePath, tree).isSuccess()) {
            tree->SetBranchAddress("Name", &(splitPath.second[0]));
            tree->SetBranchAddress("Interval", &(interval[0]));
            tree->SetBranchAddress("TriggerChain", triggerData);
            tree->SetBranchAddress("MergeMethod", mergeData.data());
            tree->Fill();
          } else {
            MsgStream log(Athena::getMessageSvc(), "OfflineHistogramProvider");
            log << MSG::ERROR
                << "Failed to retrieve DQ metadata TTree " << treePath << " which is reported to exist" << endmsg;
          }
        }
      }
    }