TrigCostAnalysis.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCOSTANALYSIS_TRIGCOSTALYSIS_H
#define TRIGCOSTANALYSIS_TRIGCOSTALYSIS_H 1
 
#include "AthenaBaseComps/AthAlgorithm.h"
#include "StoreGate/ReadHandleKeyArray.h"
#include "xAODTrigger/TrigCompositeContainer.h"
#include "TrigConfData/HLTMenu.h"
#include "TrigCompositeUtils/AlgToChainTool.h"
 
#include "EnhancedBiasWeighter/EnhancedBiasWeighter.h"
 
#include "Gaudi/Parsers/Factory.h"
#include "GaudiKernel/ITHistSvc.h"
 
#include "MonitoredRange.h"
 
#include <unordered_map>
#include <mutex>
 
#include "TH1.h"
#include "TTree.h"

class TrigCostAnalysis: public ::AthAlgorithm { 
  public: 

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

    virtual ~TrigCostAnalysis() = default; 

    virtual StatusCode initialize() final;

    virtual StatusCode start();

    virtual StatusCode execute(const EventContext& ctx) final;

    virtual StatusCode finalize() final;

    TH1* bookGetPointer(TH1* hist, const std::string& tDir = "") const;
 
    ServiceHandle<ITHistSvc> m_histSvc{ this, "THistSvc", "THistSvc/THistSvc", "Histogramming svc" };
 
    Gaudi::Property<bool> m_singleTimeRange { this, "UseSingleTimeRange", false,
      "Use a single time range rather than splitting by LB" };
 
    Gaudi::Property<std::string> m_singleTimeRangeName { this, "SingleTimeRangeName", "All",
      "Name for single time range" };
 
    Gaudi::Property<std::string> m_additionalHashMap { this, "AdditionalHashMap", "TrigCostRootAnalysis/hashes2string_29042021.txt",
      "Used to load strings corresponding to algorithms which are not explicitly scheduled by chains. To be updated periodically." };
 
    Gaudi::Property<std::vector<std::string>> m_additionalHashList { this, "AdditionalHashList", {},
      "Used to load strings corresponding to algorithms which are not explicitly scheduled by chains." };
 
    Gaudi::Property<size_t> m_TimeRangeLengthLB { this, "TimeRangeLengthLB", 50,
      "Length of each variable length Time Range in LB" };
 
    Gaudi::Property<size_t> m_maxTimeRange { this, "MaxTimeRanges", 5,
      "Maximum number of allowed time ranges" };
 
    Gaudi::Property<bool> m_doMonitorAlgorithm { this, "DoMonitorAlgs", true,
      "Monitor individual algorithms by instance name" };
 
    Gaudi::Property<bool> m_doMonitorAlgorithmClass { this, "DoMonitorAlgClass", true,
      "Monitor individual algorithms by instance class type name" };      
 
    Gaudi::Property<bool> m_doMonitorGlobal { this, "DoMonitorGlobal", true,
      "Monitor global event properties" };
 
    Gaudi::Property<bool> m_doMonitorThreadOccupancy { this, "DoMonitorThreadOccupancy", true,
      "Monitor algorithm occupancy load of individual threads in an MT execution environment" };
 
    Gaudi::Property<bool> m_doMonitorChain { this, "DoMonitorChain", true,
      "Monitor individual chains by instance name" };
 
    Gaudi::Property<bool> m_doMonitorChainAlgorithm { this, "DoMonitorChainAlgorithm", false,
      "Monitor algorithms associated with chains by instance name" };
 
    Gaudi::Property<bool> m_doMonitorSequence { this, "DoMonitorSequence", true,
      "Monitor individual sequences by name" };
 
    Gaudi::Property<bool> m_useEBWeights { this, "UseEBWeights", true,
      "Apply Enhanced Bias weights" };
 
    Gaudi::Property<size_t> m_maxFullEventDumps { this, "MaxFullEventDumps", 10,
      "Maximum number of full event summaries which will be dumped" };
 
    Gaudi::Property<uint64_t> m_fullEventDumpProbability { this, "FullEventDumpProbability", 10,
      "Save a full record of one in every N events, up to MaxFullEventDumps." }; 
 
    Gaudi::Property<float> m_baseEventWeight { this, "BaseEventWeight", true,
      "Base events weight, other weights may be multiplied on top of this one." };
 
  Gaudi::Property<std::set<std::string>> m_excludeAlgsFromChain {
    this, "ExcludeAlgsFromChainTime", {}, "Algorithms to exclude from chain time calculation"};
 
  SG::ReadHandleKey<xAOD::TrigCompositeContainer> m_costDataKey { this, "CostReadHandleKey", "HLT_TrigCostContainer",
      "Trigger cost payload container for algorithms" };
 
    SG::ReadHandleKey<xAOD::TrigCompositeContainer> m_metadataDataKey { this, "CostMetadataWriteHandleKey", "HLT_RuntimeMetadata",
      "TrigComposite collections with additional cost metadata" };
 
    SG::ReadHandleKey<TrigConf::HLTMenu> m_HLTMenuKey{this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu",
      "HLT Menu"};
 
    ToolHandle<IEnhancedBiasWeighter> m_enhancedBiasTool{this, "EnhancedBiasTool", "",
      "Enhanced bias weighting tool."};
 
    ToolHandle<TrigCompositeUtils::AlgToChainTool> m_algToChainTool{this, "AlgToChainTool", "",
      "Tool to retrieve chains for algorithm."};
   
  private:

    bool checkDoFullEventDump(const EventContext& context, const CostData& costData);

    StatusCode getRange(const EventContext& context, MonitoredRange*& range);

    StatusCode dumpEvent(const EventContext& context) const;

    StatusCode registerMonitors(MonitoredRange* range);

    float getWeight(const EventContext& context);

    uint32_t getOnlineSlot(const xAOD::TrigCompositeContainer* costCollection) const;

    StatusCode checkUpdateMaxView(const size_t max);

    void writeMetadata();
 
    std::unordered_map<std::string, std::unique_ptr<MonitoredRange> > m_monitoredRanges; 
    std::unordered_map<uint32_t, std::string > m_algTypeMap; 
    std::set<std::string> m_storeIdentifiers; 
    TTree* m_metadataTree; 
 
    mutable std::atomic<size_t> m_fullEventDumps; 
    mutable std::atomic<size_t> m_maxViewsNumber; 
    std::mutex m_addHostnameMutex; 
    mutable std::set<std::string> m_hostnames ATLAS_THREAD_SAFE; 
 
}; 
 
#endif // TRIGCOSTANALYSIS_TRIGCOSTALYSIS_H