xAODConfigSvc.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCONFXAOD_XAODCONFIGSVC_H
#define TRIGCONFXAOD_XAODCONFIGSVC_H
 
// Gaudi/Athena include(s):
#include "AthenaKernel/SlotSpecificObj.h"
#include "AthenaBaseComps/AthService.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/ServiceHandle.h"
#include "StoreGate/StoreGateSvc.h"
 
// Trigger include(s):
#include "TrigConfInterfaces/ITrigConfigSvc.h"
#include "TrigConfL1Data/CTPConfig.h"
#include "TrigConfL1Data/BunchGroupSet.h"
#include "TrigConfHLTData/HLTChainList.h"
#include "TrigConfHLTData/HLTSequenceList.h"
 
#include "TrigConfData/HLTMenu.h"
#include "TrigConfData/HLTMonitoring.h"
#include "TrigConfData/L1Menu.h"
#include "TrigConfData/HLTPrescalesSet.h"
#include "TrigConfData/L1PrescalesSet.h"
#include "TrigConfData/L1BunchGroupSet.h"
 
// xAOD include(s):
#include "xAODTrigger/TriggerMenu.h"
#include "xAODTrigger/TriggerMenuContainer.h"
#include "xAODTrigger/TriggerMenuAuxContainer.h"
#include "xAODTrigger/TriggerMenuJson.h"
#include "xAODTrigger/TriggerMenuJsonContainer.h"
#include "xAODTrigger/TriggerMenuJsonAuxContainer.h"
#include "xAODTrigger/TrigConfKeys.h"
#include "xAODTrigger/BunchConfKey.h"
 
#include <shared_mutex>
 
namespace TrigConf {

   struct MenuPtrWrapper {
      MenuPtrWrapper() : m_ptr(nullptr) {}
      const xAOD::TriggerMenu* m_ptr;
   };

   struct TriggerMenuJsonPtrWrapper {
      TriggerMenuJsonPtrWrapper() : m_ptr(nullptr) {}
      const xAOD::TriggerMenuJson* m_ptr;
   };

   class xAODConfigSvc : public extends<AthService, ITrigConfigSvc, IIncidentListener> {
 
   public:
      xAODConfigSvc( const std::string& name, ISvcLocator* svcLoc );

      virtual StatusCode initialize() override;
      virtual StatusCode finalize() override;


      virtual const CTPConfig* ctpConfig() const override;

      virtual const ThresholdConfig* thresholdConfig() const override {
         return 0;
      }

      virtual const BunchGroupSet* bunchGroupSet() const override;

      virtual uint32_t lvl1PrescaleKey() const override;

      virtual uint32_t bunchGroupSetKey() const override;



      virtual const HLTChainList& chains() const override;

      virtual const HLTSequenceList& sequences() const override;

      virtual uint32_t masterKey() const override;

      virtual uint32_t hltPrescaleKey() const override;



      virtual const Muctpi* muctpiConfig() const override {
         return 0;
      }



      virtual const HLTMenu& hltMenu(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

      virtual const HLTMonitoring& hltMonitoring(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

      virtual const L1Menu& l1Menu(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

      virtual const HLTPrescalesSet& hltPrescalesSet(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

      virtual const L1PrescalesSet& l1PrescalesSet(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;

      virtual const L1BunchGroupSet& l1BunchGroupSet(const EventContext& ctx = Gaudi::Hive::currentContext()) const override;


      virtual void handle( const Incident& inc ) override;
 
      std::string configurationSource() const override {
         return "";
      }
 
   private:
      StatusCode readMetadata();
      StatusCode prepareEvent();

      void copyMetadataToPersonalStore(const xAOD::TriggerMenuJsonContainer* input, xAOD::TriggerMenuJsonContainer* existing);

      StatusCode prepareEventRun3Athena(const EventContext& context);

      StatusCode prepareEventxAODTriggerMenuJson(const xAOD::TrigConfKeys* keys, const xAOD::BunchConfKey* bgKey, const EventContext& context);

      StatusCode prepareEventxAODTriggerMenu(const xAOD::TrigConfKeys* keys, const EventContext& context);

      StatusCode loadPtree(const std::string& humanName, 
                           const xAOD::TriggerMenuJsonContainer* metaContainer, 
                           const uint32_t keyToCheck,
                           TriggerMenuJsonPtrWrapper& cacheOfLoadedMenuPtr,
                           DataStructure& dataStructure,
                           const bool optional = false);
 
      SG::ReadHandleKey<xAOD::TrigConfKeys> m_eventKey{this, "EventObjectName", "TrigConfKeys", 
        "Key for the event-level configuration identifier object"};
 
      SG::ReadHandleKey<xAOD::BunchConfKey> m_eventBGKey{this, "BGKeysObjectName", "BunchConfKey", 
        "Key for the event-level bunchgroup configuration identifier object. Only written from late 2021, optional input."};

      Gaudi::Property<std::string> m_metaName{this, "MetaObjectName", "TriggerMenu", 
        "Key for the trigger configuration metadata object"};


      Gaudi::Property< std::string > m_metaNameJSON_hlt {this, "JSONMetaObjectNameHLT", "TriggerMenuJson_HLT",
        "StoreGate key for the xAOD::TriggerMenuJson HLT configuration object"};
 
      Gaudi::Property< std::string > m_metaNameJSON_hltmonitoring {this, "JSONMetaObjectNameHLTMonitoring", "TriggerMenuJson_HLTMonitoring",
        "StoreGate key for the xAOD::TriggerMenuJson HLT monitoring configuration object"};
 
      Gaudi::Property< std::string > m_metaNameJSON_l1 {this, "JSONMetaObjectNameL1", "TriggerMenuJson_L1",
        "StoreGate key for the xAOD::TriggerMenuJson L1 configuration object"};
 
      Gaudi::Property< std::string > m_metaNameJSON_hltps {this, "JSONMetaObjectNameHLTPS", "TriggerMenuJson_HLTPS",
        "StoreGate key for the xAOD::TriggerMenuJson HLT prescales configuration object"};
 
      Gaudi::Property< std::string > m_metaNameJSON_l1ps {this, "JSONMetaObjectNameL1PS", "TriggerMenuJson_L1PS",
        "StoreGate key for the xAOD::TriggerMenuJson L1 prescales configuration object"};
 
      Gaudi::Property< std::string > m_metaNameJSON_bg {this, "JSONMetaObjectNameBunchgroup", "TriggerMenuJson_BG",
        "StoreGate key for the xAOD::TriggerMenuJson BunchGroup configuration object"};


 
      SG::ReadHandleKey<HLTMenu> m_hltMenuKey{this, "HLTTriggerMenu", "DetectorStore+HLTTriggerMenu",
        "HLT Menu Key, for when UseInFileMetadata=False. From the DetectorStore."};
 
      SG::ReadHandleKey<L1Menu> m_l1MenuKey{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu",
        "L1 Menu Key, for when UseInFileMetadata=False. From the DetectorStore"};
 
      SG::ReadCondHandleKey<TrigConf::HLTPrescalesSet> m_HLTPrescaleSetKey{this, "HLTPrescales", "HLTPrescales", 
         "HLT prescales set condition handle, for when UseInFileMetadata=False"};
 
       SG::ReadCondHandleKey<TrigConf::L1PrescalesSet> m_L1PrescaleSetKey{this, "L1Prescales", "L1Prescales", 
         "L1 prescales set condition handle, for when UseInFileMetadata=False"};
       
       SG::ReadCondHandleKey<TrigConf::L1BunchGroupSet> m_L1BunchGroupSetKey{this, "L1BunchGroup", "L1BunchGroup", "L1 Bunch groups"}; 
 
      Gaudi::Property<bool> m_useInFileMetadata{this, "UseInFileMetadata", true, "Flag for reading all configuration from the input POOL file(s). "
        "This mode should be used everywhere except for: RAWtoALL from bytestream. "
        "If set to false, only the R3 configuration is supported."};
 
      Gaudi::Property<bool> m_stopOnFailure{this, "StopOnFailure", true, "Flag for stopping the job in case of a failure"};
      bool m_isInFailure{false};

      std::unique_ptr<xAOD::TriggerMenuAuxContainer> m_tmcAux;
      std::unique_ptr<xAOD::TriggerMenuContainer> m_tmc;
 
      // The menu currently being used by each slot (wrapped 'const xAOD::TriggerMenu' ptr)
      SG::SlotSpecificObj<MenuPtrWrapper> m_menu;

      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_hltJsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_hltJson;
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_hltmonitoringJsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_hltmonitoringJson;
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_l1JsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_l1Json;
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_hltpsJsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_hltpsJson;
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_l1psJsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_l1psJson;
      std::unique_ptr<xAOD::TriggerMenuJsonAuxContainer> m_bgJsonAux;
      std::unique_ptr<xAOD::TriggerMenuJsonContainer> m_bgJson;
 
      // The menu JSONs being used in the current event by each slot (wrapped 'const xAOD::TriggerMenuJson' ptr)
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentHltJson;
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentHltmonitoringJson;
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentL1Json;
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentHltpsJson;
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentL1psJson;
      SG::SlotSpecificObj<TriggerMenuJsonPtrWrapper> m_currentBgJson;
 
      // The decoded menu JSON data stored in ptree objects
      SG::SlotSpecificObj<HLTMenu> m_currentHlt;
      SG::SlotSpecificObj<HLTMonitoring> m_currentHltmonitoring;
      SG::SlotSpecificObj<L1Menu> m_currentL1;
      SG::SlotSpecificObj<HLTPrescalesSet> m_currentHltps;
      SG::SlotSpecificObj<L1PrescalesSet> m_currentL1ps;
      SG::SlotSpecificObj<L1BunchGroupSet> m_currentBg;

      std::shared_mutex m_sharedMutex;
 

      SG::SlotSpecificObj<CTPConfig> m_ctpConfig;
      SG::SlotSpecificObj<HLTChainList> m_chainList;
      SG::SlotSpecificObj<HLTSequenceList> m_sequenceList;
      SG::SlotSpecificObj<BunchGroupSet> m_bgSet;

      ServiceHandle< StoreGateSvc > m_metaStore{this, "MetaDataStore", "StoreGateSvc/InputMetaDataStore"};

      bool m_triggerMenuContainerAvailable{false};
      bool m_menuJSONContainerAvailable{false};
 
   }; // class xAODConfigSvc
 
} // namespace TrigConf
 
 
 
#endif // TRIGCONFXAOD_XAODCONFIGSVC_H