GenericMonitoringTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_GenericMonitoringTool_h
#define AthenaMonitoringKernel_GenericMonitoringTool_h
 
#include <functional>
#include <vector>
#include <mutex>
#include <memory>
 
#include "TH1.h"
#include "TH2.h"
#include "TProfile.h"
#include "TProfile2D.h"
 
#include "GaudiKernel/ITHistSvc.h"
 
#include "AthenaBaseComps/AthAlgTool.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 const ServiceHandle<ITHistSvc>& histogramService() const { return m_histSvc; }
  virtual uint32_t runNumber();
  virtual uint32_t lumiBlock();
 
private:
  void invokeFillersDebug(const std::shared_ptr<Monitored::HistogramFiller>& filler,
                          const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& monitoredVariables) const;
  
  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; 
  mutable std::map<std::vector<std::string>,std::unique_ptr<std::vector<std::shared_ptr<Monitored::HistogramFiller>>>,std::less<>> m_fillerCacheMap ATLAS_THREAD_SAFE; 
  mutable std::mutex m_cacheMutex;
 
};
 
class VoidMonitoringTool : public ToolHandle<GenericMonitoringTool> {
public:
  VoidMonitoringTool(const IInterface* parent) :
    ToolHandle<GenericMonitoringTool>("", parent) {}
};
 
#endif /* AthenaMonitoringKernel_GenericMonitoringTool_h */