ManagedMonitorToolBase.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ManagedMonitorToolBase_H
#define ManagedMonitorToolBase_H
 
#include <string>
#include <vector>
#include <map>
#include <set>
 
#include "GaudiKernel/ITHistSvc.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/StatusCode.h"
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaMonitoring/AthenaMonManager.h"
#include "AthenaMonitoring/IDQFilterTool.h"
#include "AthenaMonitoring/IMonitorToolBase.h"
#include "AthenaMonitoring/ITriggerTranslatorTool.h"
#include "LumiBlockData/LuminosityCondData.h"
#include "LumiBlockData/LBDurationCondData.h"
#include "LumiBlockData/TrigLiveFractionCondData.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "TrigDecisionInterface/ITrigDecisionTool.h"
 
#include "TGraph.h"
#include "TH1.h"
#include "TH2.h"
#include "TTree.h"
#include "TEfficiency.h"
 
class EventContext;
namespace Trig {
   class ITrigDecisionTool;
}

 
class ManagedMonitorToolBase : public AthAlgTool, virtual public IMonitorToolBase
{
   public:

      enum Interval_t { file = 0, eventsBlock, lumiBlock,
         lowStat, medStat, higStat,
         run, fill, all };

      enum MgmtAttr_t { ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2};
 

 
      class MonGroup {
         public:
 
            inline MonGroup( ManagedMonitorToolBase* tool, const std::string& system,
                  Interval_t interval )
               : m_tool(tool), m_system(system), m_interval(interval), m_histo_mgmt(ATTRIB_MANAGED), m_chain(""), m_merge("") { }
 
            inline MonGroup( ManagedMonitorToolBase* tool, const std::string& system,
                  Interval_t interval, MgmtAttr_t histo_mgmt )
               : m_tool(tool), m_system(system), m_interval(interval), m_histo_mgmt(histo_mgmt), m_chain(""), m_merge("") { }
            
            inline MonGroup( ManagedMonitorToolBase* tool, const std::string& system,
                  Interval_t interval, MgmtAttr_t histo_mgmt, const std::string& chain )
               : m_tool(tool), m_system(system), m_interval(interval), m_histo_mgmt(histo_mgmt), m_chain(chain), m_merge("") { }
 
            inline MonGroup( ManagedMonitorToolBase* tool, const std::string& system,
                  Interval_t interval, MgmtAttr_t histo_mgmt, const std::string& chain,
                  const std::string& merge )
               : m_tool(tool), m_system(system), m_interval(interval), m_histo_mgmt(histo_mgmt), m_chain(chain), m_merge(merge) { }
 

              StatusCode regHist( TH1* h );
 

 
            StatusCode getHist( TH1*& h, const std::string& hName );
 

 
            StatusCode getHist( TH2*& h, const std::string& hName );
 

 
            StatusCode regEfficiency( TEfficiency* e );
 
        
 
            StatusCode regGraph( TGraph* g );
 

 
            StatusCode regTree( TTree* t );
 
 
            StatusCode writeAndDelete( TH1* h);
 

 
            StatusCode deregHist( TH1* h );
 

 
            StatusCode deregGraph( TGraph* g );
 

 
            StatusCode deregObject( const std::string& objName );
 

 
            StatusCode deregAll();
 
 
            inline const std::string&  system()   const { return m_system; }
            inline Interval_t          interval() const { return m_interval; }
            inline MgmtAttr_t          histo_mgmt() const { return m_histo_mgmt; }
            inline const std::string&  chain()    const { return m_chain; }
            inline const std::string&  merge()    const { return m_merge; }

 
            typedef std::map<std::string,TH1*>  HistMap_t;
 

 
            inline HistMap_t&          map()            { return m_map; }
 
        //Copy and assignment constructors! To forbid eventually, but for now we monitor their usage:
            MonGroup( const MonGroup & o )
                : m_tool(o.m_tool),
                  m_system(o.m_system),
                  //m_level(o.m_level),
                  m_interval(o.m_interval),
                  m_histo_mgmt(o.m_histo_mgmt),
                  m_chain(o.m_chain),
                  m_merge(o.m_merge),
                  m_map(o.m_map)
                  { 
                      badusage(); 
                  }
 
            MonGroup & operator= ( const MonGroup & o )
                {
              if (&o != this) {
                m_tool = o.m_tool;
                m_system = o.m_system;
                //m_level = o.m_level;
                m_interval = o.m_interval;
                m_histo_mgmt = o.m_histo_mgmt;
                m_chain = o.m_chain;
                m_merge = o.m_merge;
                m_map = o.m_map;
              }
              badusage();
          return *this;
        }
        static unsigned ncopies();
         private:
            inline MonGroup() { }
            ManagedMonitorToolBase*  m_tool;
            std::string              m_system;
            Interval_t               m_interval;
            MgmtAttr_t               m_histo_mgmt;
            std::string              m_chain;
            std::string              m_merge;
            HistMap_t                m_map;
            static void badusage();
      };
 
      
      template <class T>
      class MgmtParams {
          public:
              inline MgmtParams(T* templateHist, const MonGroup& group)
                 : m_templateHist(templateHist), m_group(group) { }
 
              T* m_templateHist;
              MonGroup m_group;
                
      };
 

 
      class StreamNameFcn {
         public:
            virtual ~StreamNameFcn(){};

 
            virtual std::string getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval=false ) = 0;
    
 
            virtual std::string getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval ) = 0;
 
            static void parseString(const std::string& streamName, std::string& root, std::string& rem); 
      };

 
      static std::string intervalEnumToString( Interval_t interval );
 

 
      static Interval_t intervalStringToEnum( const std::string& str );
 
 
      ManagedMonitorToolBase( const std::string & type, const std::string & name,
            const IInterface* parent ); 
 
      virtual ~ManagedMonitorToolBase();
 

 
      virtual StreamNameFcn* streamNameFunction();
 
 
      virtual StatusCode initialize();

 
      virtual StatusCode bookHists();

 
      virtual StatusCode fillHists(const EventContext& ctx);

 
      virtual StatusCode finalHists();
 

 
      virtual StatusCode bookHistograms();
      

 
      virtual StatusCode bookHistogramsRecurrent();
 

 
      virtual StatusCode fillHistograms(const EventContext& ctx);
 

 
      virtual StatusCode procHistograms( );
 

 
      virtual void setMonManager( AthenaMonManager* manager );
 

      virtual StatusCode regHist( TH1* h, const std::string& system,
                 Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string& chain = "", const std::string& merge = "" );

      virtual StatusCode regHist( TH1* h, const MonGroup& group );
 

 
      virtual StatusCode getHist( TH1*& h, const std::string& hName, const std::string& system, Interval_t interval );

 
      virtual StatusCode getHist( TH1*& h, const std::string& hName, const MonGroup& group );
 

 
      virtual StatusCode getHist( TH2*& h, const std::string& hName, const std::string& system,
            Interval_t interval );

 
      virtual StatusCode getHist( TH2*& h, const std::string& hName, const MonGroup& group );
 

      virtual StatusCode regEfficiency( TEfficiency* e, const MonGroup& group );
 
 

 
 
      virtual StatusCode regGraph( TGraph* g, const std::string& system,
            Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string& chain = "", const std::string& merge = "" );

 
      virtual StatusCode regGraph( TGraph* g, const MonGroup& group );
 

 
      virtual StatusCode regTree( TTree* t, const std::string& system,
            Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string& chain = "", const std::string& merge = "" );

 
      virtual StatusCode regTree( TTree* t, const MonGroup& group );
 

 
      virtual StatusCode writeAndDelete( TH1* h, const MonGroup& group );
 

 
      virtual StatusCode deregHist( TH1* h );
 

 
      virtual StatusCode deregGraph( TGraph* g );
 

 
      virtual StatusCode deregObject( const std::string& objName, const std::string& system, Interval_t interval );
 

 
      virtual StatusCode deregObject( const std::string& objName, const MonGroup& group );
 

 
      virtual StatusCode setupOutputStreams( std::vector<std::string> Mapping
            = std::vector<std::string>() );
 

 
      virtual StatusCode runStat();
 

 
      virtual StatusCode checkHists( bool calledFromFinalize );
 
      virtual bool preSelector();
 

       virtual float lbAverageInteractionsPerCrossing (const EventContext& ctx) const;

       virtual float lbInteractionsPerCrossing (const EventContext& ctx) const;

       virtual float lbAverageLuminosity (const EventContext& ctx) const;

       virtual float lbLuminosityPerBCID (const EventContext& ctx) const;

       virtual double lbDuration (const EventContext& ctx) const;

       virtual float lbAverageLivefraction (const EventContext& ctx) const;

       virtual float livefractionPerBCID (const EventContext& ctx) const;

       virtual double lbLumiWeight (const EventContext& ctx) const;
 
 
   protected:
      std::map< Interval_t, std::vector< MgmtParams<TH1> > > m_templateHistograms;
      // Runs over the vector of managed histograms, register clonned histogram and saves it to a file.
      StatusCode regManagedHistograms(std::vector< MgmtParams<TH1> >& templateHistograms);
 
      std::map< Interval_t, std::vector< MgmtParams<TGraph> > > m_templateGraphs;
      // Runs over the vector of managed graphs, register clonned graph and saves it to a file.
      StatusCode regManagedGraphs(std::vector< MgmtParams<TGraph> >& templateGraphs);
 
      std::map< Interval_t, std::vector< MgmtParams<TTree> > > m_templateTrees;
      // Runs over the vector of managed trees, register clonned tree and saves it to a file.
      StatusCode regManagedTrees(std::vector< MgmtParams<TTree> >& templateTrees);
 
      std::map< Interval_t, std::vector< MgmtParams<TEfficiency> > > m_templateEfficiencies;
      // Runs over the vector of managed graphs, register clonned graph and saves it to a file.
      StatusCode regManagedEfficiencies(std::vector< MgmtParams<TEfficiency> >& templateEfficiencies);
 
      std::vector<std::string> m_vTrigChainNames, m_vTrigGroupNames;
      StatusCode parseList(const std::string&, std::vector<std::string>&);
      void updateTriggersForGroups(std::vector<std::string>&);
 
      StatusCode registerMetadata(const std::string& streamName, const std::string& hName, const MonGroup& group);

      StatusCode THistSvc_deReg_fixTGraph(TFile* file, TGraph* theGraph, std::string& directoryName);
 
      inline unsigned int get_nEvents() const {
          return m_nEvents; 
      }
 
      inline long get_procNEventsProp() const {
          return m_procNEventsProp;
      }
 
      class OutputMetadata {
         public:
            OutputMetadata( TTree* metadata );
            virtual ~OutputMetadata();
            OutputMetadata (const OutputMetadata&) = delete;
            OutputMetadata& operator= (const OutputMetadata&) = delete;
 
            virtual void fill( const std::string& name,
                  Interval_t interval,
                  std::string trigger,
                  std::string merge );
 
         protected:
            void copyString( char* to, const std::string& from );
            const int m_charArrSize;
            TTree* m_metadata;
            char* m_nameData;
            //char* m_levelData;
            char* m_intervalData;
            char* m_triggerData;
            char* m_mergeData;
      };
 
 
      class DefaultStream : public StreamNameFcn {
         public:
            DefaultStream( const std::string& fileKey )
               : m_fileKey(fileKey) { }
            virtual ~DefaultStream() { }
            virtual std::string getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval=false );
            virtual std::string getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval );
 
         private:
            const std::string  m_fileKey;
      };
 
 
      class NoOutputStream : public StreamNameFcn {
         public:
            virtual std::string getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval=false );
            virtual std::string getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval );
      };
 
 
      class OnlineStream : public StreamNameFcn {
         public:
            virtual std::string getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval=false );
            virtual std::string getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval );
      };
 
 
      class OfflineStream : public StreamNameFcn {
         public:
        OfflineStream( const std::string& fileKey, AthenaMonManager::DataType_t /*dataType*/,
                       AthenaMonManager::Environment_t /*environment*/ )
               : m_fileKey(fileKey),
                 m_prev_run_number(0),
                 m_prev_lumi_block(0) { }
 
            virtual ~OfflineStream() { }
            virtual std::string getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval=false );
            virtual std::string getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval );
        void updateRunLB();
 
         private:
            OfflineStream() { }
            const std::string                m_fileKey;
            //AthenaMonManager::DataType_t     m_dataType;
            //AthenaMonManager::Environment_t  m_environment;
            uint32_t m_prev_run_number, m_prev_lumi_block;
            std::set<std::string> m_ebNames;
            void getLBrange(int*,int*,int,int);
      };
 
      virtual bool trigChainsArePassed(std::vector<std::string>&);
 
      virtual StreamNameFcn* getNewStreamNameFcn() const;
 

 
      bool newLowStatIntervalFlag() const { return m_newLowStatInterval; }
      bool newMedStatIntervalFlag() const { return m_newMedStatInterval; }
      bool newHigStatIntervalFlag() const { return m_newHigStatInterval; }
      bool newLowStatFlag() const { return m_newLowStat; }
      bool newLumiBlockFlag() const { return m_newLumiBlock; }
      bool newRunFlag() const { return m_newRun; }
      bool newEventsBlockFlag() const { return m_newEventsBlock; }
      bool endOfEventsBlockFlag() const { return m_endOfEventsBlock; }
      bool endOfLowStatFlag() const { return m_endOfLowStat; }
      bool endOfLumiBlockFlag() const { return m_endOfLumiBlock; }
      bool endOfRunFlag() const { return m_endOfRun; }
 
private:
      bool m_newLowStatInterval, m_newMedStatInterval, m_newHigStatInterval;
      bool m_newLowStat, m_newLumiBlock, m_newRun;
      bool m_newEventsBlock;
      bool m_endOfEventsBlock, m_endOfLowStat, m_endOfLumiBlock, m_endOfRun;
 
protected:
      typedef std::map<std::string,OutputMetadata*> MDMap_t;
      MDMap_t m_metadataMap;
 
      AthenaMonManager* m_manager;
 
      std::string  m_managerNameProp;
 
      std::string  m_fileKey;
      std::string  m_dataTypeStr;
      std::string  m_environmentStr;
      unsigned int m_detailLevel;
 
      AthenaMonManager::DataType_t     m_dataType;
      AthenaMonManager::Environment_t  m_environment;
 
      StreamNameFcn*  m_streamNameFcn;
 
      ServiceHandle<ITHistSvc>         m_THistSvc;
      // The TrigDecisionTool, clients normally should not have to set this
      PublicToolHandle<Trig::ITrigDecisionTool>    m_trigDecTool {this, "TrigDecisionTool",""};
      // The TriggerTranslator
      PublicToolHandle<ITriggerTranslatorTool> m_trigTranslator {this,"TriggerTranslatorTool",""};
      // The filter tools, to be specified in jobOptions
      ToolHandleArray<IDQFilterTool> m_DQFilterTools {this,"FilterTools",{}};
 
      long         m_procNEventsProp;
      std::string  m_path;
      long         m_preScaleProp;
      std::string  m_triggerChainProp;
      std::string  m_triggerGroupProp;
 
      bool                m_useTrigger;
 
      unsigned int m_lastLumiBlock;
      unsigned int m_lastRun;
      int m_lastLowStatInterval, m_lastMedStatInterval, m_lastHigStatInterval;
 
      unsigned int m_nEvents;
      unsigned int m_nEventsIgnoreTrigger;
      unsigned int m_nLumiBlocks;
      bool m_haveClearedLastEventBlock;
 
 
   private:
       class GlobalDirectoryRestore {
       public:
         GlobalDirectoryRestore();
         ~GlobalDirectoryRestore();
       private:
         TDirectory* m_gd;
         TFile* m_gf;
       };
 
      //bool findStream(const std::string& id, std::string& stream, std::string& rem) const;
      //std::string dirname(std::string& dir) const;
 
      SG::ReadCondHandleKey<LuminosityCondData> m_lumiDataKey
      {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};
      SG::ReadCondHandleKey<LBDurationCondData> m_lbDurationDataKey
      {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};
      SG::ReadCondHandleKey<TrigLiveFractionCondData> m_trigLiveFractionDataKey
      {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"};
 
      bool m_bookHistogramsInitial;
      bool m_useLumi;
      float m_defaultLBDuration;
      std::set<Interval_t> m_supportedIntervalsForRebooking;
 
      // Use private implementation idiom for more flexible development.
      class Imp;
      Imp * m_d;
 
};
 
#endif