IL1TriggerByteStreamTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGT1RESULTBYTESTREAM_IL1TRIGGERBYTESTREAMTOOL_H
#define TRIGT1RESULTBYTESTREAM_IL1TRIGGERBYTESTREAMTOOL_H
 
#include "AthenaKernel/SlotSpecificObj.h"
#include "ByteStreamData/RawEvent.h" //OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment typedef
#include "StoreGate/VarHandleKey.h"
#include "StoreGate/VarHandleKeyArray.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/EventContext.h"
#include "eformat/Status.h" //eformat::STATUS_BACK enum
 
#include <vector>
#include <type_traits>
#include <cstdint>
#include <memory>

class IL1TriggerByteStreamTool : virtual public IAlgTool {
public:
  DeclareInterfaceID(IL1TriggerByteStreamTool, 1, 0);
  virtual ~IL1TriggerByteStreamTool() override = default;

  virtual StatusCode convertFromBS(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& vrobf,
                                   const EventContext& eventContext) const = 0;

  virtual StatusCode convertToBS(std::vector<OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment*>& vrobf,
                                 const EventContext& eventContext) = 0;

  virtual const std::vector<uint32_t>& robIds() const = 0;
 
protected:
  enum class ConversionMode {Undefined, Decoding , Encoding };
  template<typename RHK, typename WHK>
  inline ConversionMode getConversionMode(const RHK& readHandleKeys, const WHK& writeHandleKeys, MsgStream& msg) {
    if (readHandleKeys.empty() and not writeHandleKeys.empty()) {
      return ConversionMode::Decoding;
    }
    if (writeHandleKeys.empty() and not readHandleKeys.empty()) {
      return ConversionMode::Encoding;
    }
    if constexpr (std::is_base_of_v<SG::VarHandleKeyArray, RHK>) {
      msg << MSG::ERROR << "Exactly one of the read / write handle key arrays has to be set and the other has to"
          << " be empty, but they have " << readHandleKeys.size() << " / " << writeHandleKeys.size() << " elements"
          << endmsg;
    } else if constexpr (std::is_base_of_v<SG::VarHandleKey, RHK>) {
      msg << MSG::ERROR << "Exactly one of the read / write handle keys has to be set and the other has to"
          << " be empty, but they are \"" << readHandleKeys.key() << "\" / \"" << writeHandleKeys.key() << "\""
          << endmsg;
    }
    return ConversionMode::Undefined;
  }

  inline void clearCache(const EventContext& eventContext) {
    m_cache.get(eventContext)->clear();
  }

  inline uint32_t* newRodData(const EventContext& eventContext, const size_t size) {
    Cache* cache = m_cache.get(eventContext);
    cache->rodData.push_back(std::make_unique<uint32_t[]>(size));
    return cache->rodData.back().get();
  }

  inline OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment* newRobFragment(
    const EventContext& eventContext,
    uint32_t source_id,
    uint32_t ndata,
    const uint32_t* data,
    uint32_t detev_type = 0,
    uint32_t status_position = eformat::STATUS_BACK) {
 
    Cache* cache = m_cache.get(eventContext);
    const EventIDBase& eid = eventContext.eventID();
    cache->robFragments.push_back(std::make_unique<OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment>(
      source_id,
      eid.run_number(),
      0, // lvl1_id will be overwritten downstream from full event fragment
      eid.bunch_crossing_id(),
      0, // lvl1_type will be overwritten downstream from full event fragment
      detev_type,
      ndata,
      data,
      status_position
    ));
    return cache->robFragments.back().get();
  }
 
private:
  struct Cache {
    std::vector<std::unique_ptr<uint32_t[]>> rodData;
    std::vector<std::unique_ptr<OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment>> robFragments;
    ~Cache() {clear();}
    void clear() {
      rodData.clear();
      robFragments.clear();
    }
  };
  SG::SlotSpecificObj<Cache> m_cache; // one cache per event slot
};
 
#endif // TRIGT1RESULTBYTESTREAM_IL1TRIGGERBYTESTREAMTOOL_H