TriggerEDMSerialiserTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGOUTPUTHANDLING_TRIGGEREDMSERIALISERTOOL_H
#define TRIGOUTPUTHANDLING_TRIGGEREDMSERIALISERTOOL_H
 
#include <string>
#include "AthenaBaseComps/AthAlgTool.h"
#include "CxxUtils/ConcurrentToValMap.h"
#include "CxxUtils/SimpleUpdater.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/IClassIDSvc.h"
#include "GaudiKernel/ServiceHandle.h"
#include "xAODCore/AuxSelection.h"
#include "xAODTrigger/TrigCompositeContainer.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "AthenaKernel/IAthenaSerializeSvc.h"
#include "AthenaKernel/IDictLoaderSvc.h"
#include "AthenaMonitoringKernel/Monitored.h"
#include "TrigOutputHandling/HLTResultMTMakerTool.h"
#include "TrigSerializeTP/TrigSerTPTool.h"
#include "Gaudi/Parsers/Factory.h" // Needed to declare less common Property types
 
// Forward declarations
class DataObject;

class TriggerEDMSerialiserTool: public extends<AthAlgTool, HLTResultMTMakerTool>
{
 
 public:
 
  TriggerEDMSerialiserTool( const std::string& type,
         const std::string& name,
         const IInterface* parent );
 
  virtual ~TriggerEDMSerialiserTool() override = default;
  virtual StatusCode fill( HLT::HLTResultMT& resultToFill, const EventContext& ctx ) const override;
 
  virtual StatusCode  initialize() override;
 
 private:
  friend StatusCode tester( TriggerEDMSerialiserTool* );
  Gaudi::Property< std::vector< std::string > > m_collectionsToSerialize {
    this, "CollectionsToSerialize", {},
    "EDM streaming configuration \'collectionKeyType;module1,module2,...[;allowTruncation]\' where collectionKeyType is a string "
    "formatted like for AthenaOutputStream, e.g. TYPE#SG.aux1.aux2..etc. For xAOD classes the typedef type should be "
    "used and the _vN version number is automatically detected. For old T/P classes the persistent version has to be "
    "given. Module IDs following the semicolon are the HLT result ROB module IDs to which the collection should be "
    "written. ID=0 is the main result, other IDs are used for data scouting. The optional allowTruncation "
    "indicates if the collection can be truncated without raising an ERROR.",
    "OrderedSet<std::string>"
  };
  Gaudi::Property<bool> m_saveDynamic {
    this, "SaveDynamic", true, "If false skips serialising of dynamic variables. Use for test purpose only."
  };
  Gaudi::Property<std::map<uint16_t,uint32_t>> m_truncationThresholds {
    this, "TruncationThresholds", {}, "HLT result truncation thresholds. Key is module ID, value is max size in bytes"
  };
  Gaudi::Property<int> m_eventSizeHardLimitMB {
    this, "EventSizeHardLimitMB", -1,
    "Hard limit for output event size in megabytes. Set automatically in initialize from run parameters. "
    "In partition, it corresponds to DCM sbaBlockSize_MiB. Value <0 means no limit."
  };
  Gaudi::Property<float> m_fullResultTruncationFrac {
    this, "FullResultTruncationFrac", 0.8,
    "Fraction of EventSizeHardLimitMB which defines the limit on the total size of HLT output (sum of all modules)"
  };

  SG::WriteHandleKey<xAOD::TrigCompositeContainer> m_debugInfoWHKey {
    this, "DebugInfoWHKey", "TruncationDebugInfo"
  };

  SG::ReadHandleKey<TrigCompositeUtils::DecisionContainer> m_debugNavigationSummaryRHKey {
    this, "NavigationSummaryRHKey", "HLTNav_Summary"
  };

  struct Address {
    enum class Category : uint8_t { xAODInterface, xAODAux, OldTP, xAODDecoration, None };
    enum class Truncation { Error, Allowed };
    std::string transType;
    std::string persType; // actual versioned type
    RootType classDesc;
    CLID clid;
    std::string key;
    std::vector<uint16_t> moduleIdVec{};
    Category category{Category::None};
    Truncation truncationMode{Truncation::Error};
    xAOD::AuxSelection sel{}; 
 
    std::string transTypeName() const {return transType+"#"+key;}
    std::string persTypeName() const {return persType+"#"+key;}
  };

  using AuxIdTypeMap_t = CxxUtils::ConcurrentToValMap<SG::auxid_t, Address,
                                                      CxxUtils::SimpleUpdater,
                                                      std::hash<SG::auxid_t>,
                                                      std::equal_to<SG::auxid_t>,
                                                      SG::null_auxid>;
 
  mutable AuxIdTypeMap_t m_dynAuxAddress ATLAS_THREAD_SAFE;

  struct TruncationInfo {
    const Address* addrPtr{nullptr};
    size_t size{0};
    bool recorded{false};
  };

  using TruncationInfoMap = std::unordered_map<uint16_t, std::vector<TruncationInfo>>;
 
  std::vector< Address > m_toSerialise; // postprocessed configuration info
 
  ServiceHandle<IClassIDSvc> m_clidSvc{ this, "ClassIDSvc", "ClassIDSvc",
      "Service to translate class name to CLID" };
  ServiceHandle<IAthenaSerializeSvc> m_serializerSvc{ this, "Serializer", "AthenaRootSerializeSvc",
      "Service to translate transient to persistent representation" };
 
  ToolHandle<TrigSerTPTool> m_tpTool{ this, "TPTool", "TrigSerTPTool/TrigSerTPTool",
      "Tool to do Transient/Persistent conversion (Old EDM)"};
 
  ToolHandle<GenericMonitoringTool> m_monTool{ this, "MonTool", "", "Monitoring tool" };

  StatusCode addCollectionToSerialise(const std::string& typeKeyAuxIDs, std::vector<Address>& addressVec) const;

  static StatusCode makeHeader( const TriggerEDMSerialiserTool::Address& address, std::vector<uint32_t>& buffer  );

  StatusCode fillPayload( const void* data, size_t sz, std::vector<uint32_t>& buffer ) const;
 

  StatusCode serialiseContainer( void* data, const Address& address, std::vector<uint32_t>& buffer ) const;
  StatusCode serialisexAODAuxContainer( void* data, const Address& address, std::vector<uint32_t>& buffer, SGImplSvc* evtStore ) const;

  StatusCode serialiseTPContainer( void* data, const Address& address, std::vector<uint32_t>& buffer ) const;

  StatusCode serialiseDynAux( DataObject* dObject, const Address& address, std::vector<uint32_t>& buffer, size_t& nDynWritten ) const;

  StatusCode serialise( const Address& address, std::vector<uint32_t>& buffer, SGImplSvc* evtStore ) const;

  StatusCode tryAddData(HLT::HLTResultMT& hltResult, const uint16_t id, const std::vector<uint32_t>& data, Address::Truncation truncationMode, const std::unordered_map<uint16_t, std::vector<uint32_t>>&  deferredInterfaceBuffer) const;

  StatusCode fillDebugInfo(const TruncationInfoMap& truncationInfoMap, xAOD::TrigCompositeContainer& debugInfoCont, HLT::HLTResultMT& resultToFill, SGImplSvc* evtStore) const;

  static std::string version( const std::string& name );

  static std::set<uint16_t> activeModuleIDs(const HLT::HLTResultMT& result);
 
};
 
 
#endif //> !TRIGOUTPUTHANDLING_TRIGGEREDMSERIALISERTOOL_H