AthMonitorAlgorithm.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef ATHMONITORALGORITHM_H
#define ATHMONITORALGORITHM_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "AthenaMonitoring/IDQFilterTool.h"
#include "AthenaMonitoring/IMonitorToolBase.h"
#include "AthenaMonitoringKernel/Monitored.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandle.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
#include "LumiBlockData/LuminosityCondData.h"
#include "LumiBlockData/LBDurationCondData.h"
#include "LumiBlockData/TrigLiveFractionCondData.h"
#include "CxxUtils/transparent_string_hash.h"
#include <string_view>
#include <concepts>
 
 
namespace Trig {
class TrigDecisionTool;
}
 
class AthMonitorAlgorithm : public AthReentrantAlgorithm {
public:

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

    virtual ~AthMonitorAlgorithm();
 

    virtual StatusCode initialize() override;
 

    virtual StatusCode execute(const EventContext& ctx) const override;
 

    virtual StatusCode fillHistograms(const EventContext& ctx) const = 0;

    void fill( const ToolHandle<GenericMonitoringTool>& groupHandle,
               std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>&& variables ) const;

 
    void fill( const ToolHandle<GenericMonitoringTool>& groupHandle,
               const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& variables ) const {
        fill(groupHandle, std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>{variables});
    };

    template <typename... T>
    void fill( const ToolHandle<GenericMonitoringTool>& groupHandle, T&&... variables ) const {
        fill(groupHandle, std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>{std::forward<T>(variables)...});
    }

    void fill( std::string_view groupName,
               std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>&& variables ) const;

    void fill( std::string_view groupName,
               const std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>& variables ) const {
        fill( getGroup(groupName), std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>{variables});
    }

    template <typename S, typename... T>
    requires std::convertible_to<S, std::string_view>
    void fill( S&& groupName, T&&... variables ) const {
        fill(getGroup(std::forward<S>(groupName)), std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>>{std::forward<T>(variables)...});
    }
 // end of fill group
 

    enum class Environment_t {
        user = 0, 
        online, 
        tier0, 
        tier0Raw, 
        tier0ESD, 
        AOD, 
        altprod, 
    };
 

    enum class DataType_t {
        userDefined = 0, 
        monteCarlo, 
        collisions, 
        cosmics, 
        heavyIonCollisions, 
    };
 

    Environment_t environment() const { return m_environment; }
 

    Environment_t envStringToEnum( const std::string& str ) const;
 

    DataType_t dataType() const { return m_dataType; }
 

    DataType_t dataTypeStringToEnum( const std::string& str ) const;
 

    const ToolHandle<GenericMonitoringTool>& getGroup( std::string_view name ) const;
 

    const ToolHandle<Trig::TrigDecisionTool>& getTrigDecisionTool() const;

    bool trigChainsArePassed( const std::vector<std::string>& vTrigNames ) const;

    SG::ReadHandle<xAOD::EventInfo> GetEventInfo( const EventContext& ) const;


    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;
 // end of lumi group
 

    virtual StatusCode parseList( const std::string& line, std::vector<std::string>& result ) const;
 
 
protected:
    // Using the new way to declare JO properties: Gaudi::Property<int> m_myProperty {this,"MyProperty",0};
    ToolHandleArray<GenericMonitoringTool> m_tools {this,"GMTools",{}}; 
    // Keep TDT public until final decision from trigger on interface
    // Initialization is in the ctor to avoid requiring a header
    // dependency on TrigDecisionTool.h.
    PublicToolHandle<Trig::TrigDecisionTool> m_trigDecTool; 
    ToolHandleArray<IDQFilterTool> m_DQFilterTools {this,"FilterTools",{}}; 
 
    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"};
 
    AthMonitorAlgorithm::Environment_t m_environment; 
    AthMonitorAlgorithm::DataType_t m_dataType; 
    Gaudi::Property<std::string> m_environmentStr {this,"Environment","user"}; 
    Gaudi::Property<std::string> m_dataTypeStr {this,"DataType","userDefined"}; 
 
    Gaudi::Property<std::string> m_triggerChainString {this,"TriggerChain",""}; 
    std::vector<std::string> m_vTrigChainNames; 
 
    Gaudi::Property<std::string> m_fileKey {this,"FileKey",""}; 
    Gaudi::Property<bool> m_useLumi {this,"EnableLumi",false}; 
    Gaudi::Property<float> m_defaultLBDuration {this,"DefaultLBDuration",60.}; 
    Gaudi::Property<int> m_detailLevel {this,"DetailLevel",0}; 
    SG::ReadHandleKey<xAOD::EventInfo> m_EventInfoKey {this,"EventInfoKey","EventInfo"}; 
 
private:
    typedef std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> MonVarVec_t;
    std::string m_name;
    std::unordered_map<std::string, size_t, CxxUtils::TransparentStringHash, std::equal_to<>> m_toolLookupMap;
 
    const ToolHandle<GenericMonitoringTool> m_dummy;
 
 
   Gaudi::Property<bool> m_enforceExpressTriggers{this,
                          "EnforceExpressTriggers", false,
                          "Requires that matched triggers made the event enter the express stream"};
};
 
#endif