GenericMonitoringTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_GenericMonitoringTool_h
#define AthenaMonitoringKernel_GenericMonitoringTool_h
 
#include <functional>
#include <vector>
#include <memory>
 
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TProfile2D.h"
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "CxxUtils/ConcurrentStrToValMap.h"
#include "GaudiKernel/ITHistSvc.h"
#include "StoreGate/ReadHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
 
/* Here, by forward declaring these two classes, which appear as parameters and values
   in GenericMonitoringTool functions only as pointers (not as the objects themselves),
   we can avoid including those class headers here, moving them to the implementation
   file instead. This prevents external dependancy of the public-facing tool on the
   internals of AthenaMonitoringKernel. */
namespace Monitored {
  class HistogramFiller;
  class IMonitoredVariable;
}

namespace Monitored {
  class Group;
}
class GenericMonitoringTool : public extends<AthAlgTool, IIncidentListener> {
public:
  using extends::extends;
 
  virtual ~GenericMonitoringTool() override;
  virtual StatusCode initialize() override;
  virtual StatusCode start() override;
  virtual StatusCode stop() override;
  void handle( const Incident& ) override;

  void invokeFillers(const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& monitoredVariables) const;  
  
  StatusCode book();
  void setPath( const std::string& newPath ) { m_histoPath = newPath; }
  const std::string& getPath() const         { return m_histoPath; }
 
  virtual ServiceHandle<ITHistSvc>& histogramService() { return m_histSvc; }
  virtual uint32_t runNumber() const;
  virtual uint32_t lumiBlock() const;
 
private:
  ServiceHandle<ITHistSvc> m_histSvc { this, "THistSvc", "THistSvc", "Histogramming svc" };
  Gaudi::Property<std::string> m_histoPath { this, "HistPath", {}, "Directory for histograms [name of parent if not set]" };
  Gaudi::Property<std::vector<std::string> > m_histograms { this, "Histograms", {},  "Definitions of histograms", "OrderedSet<std::string>"};
  Gaudi::Property<bool> m_explicitBooking { this, "ExplicitBooking", false, "Do not create histograms automatically in initialize but wait until the method book is called." };
  Gaudi::Property<bool> m_failOnEmpty { this, "FailOnEmpty", true, "Fail in initialize() if no histograms defined" };
  BooleanProperty m_useCache { this, "UseCache", true, "Cache filler lookups" };
  BooleanProperty m_registerHandler { this, "RegisterHandler", true, "Use incident handler to make 'always book' plots (else only check once)" };
 
  std::vector<std::shared_ptr<Monitored::HistogramFiller>> m_fillers; 
  std::vector<std::shared_ptr<Monitored::HistogramFiller>> m_alwaysCreateFillers; 
  using fillerCache_t = CxxUtils::ConcurrentStrToValMap<std::vector<std::shared_ptr<Monitored::HistogramFiller>>, CxxUtils::SimpleUpdater>;
  mutable fillerCache_t m_fillerCacheMap ATLAS_THREAD_SAFE {fillerCache_t::Updater_t()}; 
};

class VoidMonitoringTool : public ToolHandle<GenericMonitoringTool> {
public:
  VoidMonitoringTool(const IInterface* parent) :
    ToolHandle<GenericMonitoringTool>("", parent) {}
};
 
#endif /* AthenaMonitoringKernel_GenericMonitoringTool_h */