gFexByteStreamTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
//***************************************************************************
//                           gFexByteStreamTool  -  description
//                              -------------------
//     begin                : 20 07 2022
//     email                : cecilia.tosciri@cern.ch
//  ***************************************************************************/
 
#include "gFexByteStreamTool.h"
#include "L1CaloFEXByteStream/gFexPos.h"
#include "eformat/SourceIdentifier.h"
#include "eformat/Status.h"
#include "StoreGate/WriteDecorHandle.h"
 
#include <span>
 
using ROBF = OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment;
using WROBF = OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment;
 
namespace gPos = LVL1::gFEXPos;
 
namespace {
    // std::less<> (transparent comparator) enables heterogeneous lookup, so the
    // encoder can pass string_view / string literals to find() without
    // constructing a temporary std::string at every call site.
    template<typename ContT>
    using NamedContainerMap = std::map<std::string, const ContT*, std::less<>>;
 
    // Index every container of type ContT inside the TrigComposite by its link name,
    // so the encoder can look up gRho / gBlock / gJet (all gFexJetRoIContainer) and
    // the 10 Global containers (all gFexGlobalRoIContainer) by their L1_* SG name.
    template<typename ContT>
    NamedContainerMap<ContT> indexByName(const xAOD::TrigComposite& l1) {
        NamedContainerMap<ContT> out;
        for (const std::string& name : l1.getObjectNames<ContT>()) {
            auto link = l1.objectLink<ContT>(name);
            if (!link.isValid()) continue;
            if (const ContT* c = link.getStorableObjectPointer()) out[name] = c;
        }
        return out;
    }
 
    // Return the i-th entry's word() from a named container, or 0 if missing/out-of-range.
    template<typename ContT>
    uint32_t wordAtOrZero(const NamedContainerMap<ContT>& m,
                          std::string_view name, size_t idx) {
        auto it = m.find(name);
        if (it == m.end() || !it->second || idx >= it->second->size()) return 0u;
        return it->second->at(idx)->word();
    }
 
    // Convenience for Global containers, which carry a single TOB per slice.
    template<typename ContT>
    uint32_t firstWord(const NamedContainerMap<ContT>& m, std::string_view name) {
        return wordAtOrZero(m, name, 0);
    }
 
    // Repack gFexGlobalRoI::word() (decoder's METword: sum_y in bits 0-11,
    // sum_x in bits 12-23, status/type in bits 24-30) into the per-FPGA TOB
    // layout the decoder's fillGlobal() expects on re-read (Y in bits 0-15,
    // X in bits 16-31). The whole value goes on FPGA-A; FPGA-B/C stay 0 so
    // the decoder's per-FPGA sum reproduces sum_x / sum_y.
    //
    // `signed12bit` controls sign extension of the 12-bit fields:
    //   true  for vector-component containers (METx/y, MHTx/y, MSTx/y) where
    //         the value is signed in [-2048, 2047]
    //   false for scalar-energy containers (SCALAR EJwoJ, Espresso, Ristretto,
    //         NoiseCut/Rms Scalar) where the decoder stores an unsigned value
    //         in [0, 4095]; sign-extending here would flip values >= 2048 to
    //         negative and the SCALAR decoder branch then force-zeroes them.
    uint32_t globalRoIWordToPerFpgaTob(uint32_t metWord, bool signed12bit) {
        int16_t y = static_cast<int16_t>(metWord & 0xFFF);
        if (signed12bit && (y & 0x800)) y |= 0xF000;  // sign-extend 12→16
        int16_t x = static_cast<int16_t>((metWord >> 12) & 0xFFF);
        if (signed12bit && (x & 0x800)) x |= 0xF000;
        return (static_cast<uint32_t>(static_cast<uint16_t>(x)) << 16)
             | static_cast<uint32_t>(static_cast<uint16_t>(y));
    }
}
 
gFexByteStreamTool::gFexByteStreamTool(const std::string& type,
        const std::string& name,
        const IInterface* parent)
    : base_class(type, name, parent) {}
 
StatusCode gFexByteStreamTool::initialize() {
 
    ATH_MSG_DEBUG(" ROB IDs: " << MSG::hex << m_robIds.value() << MSG::dec);
 
    // Decoder write keys (BS->xAOD); each one is initialised only if configured.
    // xAOD->BS mode now consumes RoIs from the TrigCompositeContainer passed to
    // convertToBS(), so no ReadHandleKey/ConversionMode bookkeeping is needed.
    ATH_CHECK(m_gFexRhoWriteKey                .initialize(!m_gFexRhoWriteKey                .empty()));
    ATH_CHECK(m_gFexBlockWriteKey              .initialize(!m_gFexBlockWriteKey              .empty()));
    ATH_CHECK(m_gFexJetWriteKey                .initialize(!m_gFexJetWriteKey                .empty()));
    ATH_CHECK(m_gScalarEJwojWriteKey           .initialize(!m_gScalarEJwojWriteKey           .empty()));
    ATH_CHECK(m_gMETComponentsJwojWriteKey     .initialize(!m_gMETComponentsJwojWriteKey     .empty()));
    ATH_CHECK(m_gMHTComponentsJwojWriteKey     .initialize(!m_gMHTComponentsJwojWriteKey     .empty()));
    ATH_CHECK(m_gMSTComponentsJwojWriteKey     .initialize(!m_gMSTComponentsJwojWriteKey     .empty()));
    ATH_CHECK(m_gEspressoWriteKey              .initialize(!m_gEspressoWriteKey              .empty()));
    ATH_CHECK(m_gRistrettoWriteKey             .initialize(!m_gRistrettoWriteKey             .empty()));
    ATH_CHECK(m_gMETComponentsNoiseCutWriteKey .initialize(!m_gMETComponentsNoiseCutWriteKey .empty()));
    ATH_CHECK(m_gMETComponentsRmsWriteKey      .initialize(!m_gMETComponentsRmsWriteKey      .empty()));
    ATH_CHECK(m_gScalarENoiseCutWriteKey       .initialize(!m_gScalarENoiseCutWriteKey       .empty()));
    ATH_CHECK(m_gScalarERmsWriteKey            .initialize(!m_gScalarERmsWriteKey            .empty()));
 
    // Initialize multi-slice write handle keys (only if configured with non-empty key)
    ATH_CHECK(m_gFexRhoSliceWriteKey.initialize(!m_gFexRhoSliceWriteKey.empty()));
    ATH_CHECK(m_gFexBlockSliceWriteKey.initialize(!m_gFexBlockSliceWriteKey.empty()));
    ATH_CHECK(m_gFexJetSliceWriteKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarEJwojSliceWriteKey.initialize(!m_gScalarEJwojSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsJwojSliceWriteKey.initialize(!m_gMETComponentsJwojSliceWriteKey.empty()));
    ATH_CHECK(m_gMHTComponentsJwojSliceWriteKey.initialize(!m_gMHTComponentsJwojSliceWriteKey.empty()));
    ATH_CHECK(m_gMSTComponentsJwojSliceWriteKey.initialize(!m_gMSTComponentsJwojSliceWriteKey.empty()));
    ATH_CHECK(m_gEspressoSliceWriteKey.initialize(!m_gEspressoSliceWriteKey.empty()));
    ATH_CHECK(m_gRistrettoSliceWriteKey.initialize(!m_gRistrettoSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsNoiseCutSliceWriteKey.initialize(!m_gMETComponentsNoiseCutSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarENoiseCutSliceWriteKey.initialize(!m_gScalarENoiseCutSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsRmsSliceWriteKey.initialize(!m_gMETComponentsRmsSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarERmsSliceWriteKey.initialize(!m_gScalarERmsSliceWriteKey.empty()));
 
    // Initialize slice number decoration keys for out-of-time containers.
    // Multi-slice mode is activated based on m_gFexJetSliceWriteKey being non-empty,
    // so all decoration keys are initialized based on that same condition.
    // When multi-slice mode is enabled, all OOT container keys must be configured together.
    ATH_CHECK(m_gFexRhoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gFexBlockOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gFexJetOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarEJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gMHTComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gMSTComponentsJwojOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gEspressoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gRistrettoOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsNoiseCutOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarENoiseCutOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gMETComponentsRmsOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    ATH_CHECK(m_gScalarERmsOOTDecorKey.initialize(!m_gFexJetSliceWriteKey.empty()));
    
    ATH_CHECK(m_l1MenuKey.initialize());
    
    if (!m_monTool.empty()) {
        ATH_CHECK(m_monTool.retrieve());
        ATH_MSG_INFO("Logging errors to " << m_monTool.name() << " monitoring tool");
        m_UseMonitoring = true;
    }
    
    
    return StatusCode::SUCCESS;
}
 
StatusCode gFexByteStreamTool::start() {
    // Retrieve the L1 menu configuration
    SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey);
    ATH_CHECK(l1Menu.isValid());
 
    try {
        const auto & l1Menu_gJ = l1Menu->thrExtraInfo().gJ();
        const auto & l1Menu_gLJ = l1Menu->thrExtraInfo().gLJ();
        const auto & l1Menu_gXE = l1Menu->thrExtraInfo().gXE();
        const auto & l1Menu_gTE = l1Menu->thrExtraInfo().gTE();
 
        ATH_CHECK(l1Menu_gJ.isValid());
        ATH_CHECK(l1Menu_gLJ.isValid());
        ATH_CHECK(l1Menu_gXE.isValid());
        ATH_CHECK(l1Menu_gTE.isValid());
 
        m_gJ_scale = l1Menu_gJ.resolutionMeV(); 
        m_gLJ_scale = l1Menu_gLJ.resolutionMeV(); 
        m_gXE_scale = l1Menu_gXE.resolutionMeV(); 
        m_gTE_scale = l1Menu_gTE.resolutionMeV();
    } catch (const std::exception& e) {
        ATH_MSG_ERROR("Exception reading L1Menu: " << e.what());
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
 
}
 
// BS->xAOD conversion
StatusCode gFexByteStreamTool::convertFromBS(const std::vector<const ROBF*>& vrobf, const EventContext& ctx) const {
        
    //WriteHandle for gFEX EDMs
    
    // Check if standard L1A containers should be decoded (TOBs=True mode)
    // or are disabled (TOBs=False mode, standard containers come from HLT result)
    const bool decodeStdTOBs = !m_gFexRhoWriteKey.key().empty();
 
    //---Standard L1A TOB containers (only created and recorded when decodeStdTOBs is true)
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gRhoContainer;
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gSJContainer;
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gLJContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarEJwojContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsJwojContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMHTComponentsJwojContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMSTComponentsJwojContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsNoiseCutContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsRmsContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarENoiseCutContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarERmsContainer;
 
    if (decodeStdTOBs) {
        gRhoContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexRhoWriteKey, ctx);
        gSJContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexBlockWriteKey, ctx);
        gLJContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexJetWriteKey, ctx);
        gScalarEJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarEJwojWriteKey, ctx);
        gMETComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsJwojWriteKey, ctx);
        gMHTComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMHTComponentsJwojWriteKey, ctx);
        gMSTComponentsJwojContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMSTComponentsJwojWriteKey, ctx);
        gMETComponentsNoiseCutContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsNoiseCutWriteKey, ctx);
        gMETComponentsRmsContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsRmsWriteKey, ctx);
        gScalarENoiseCutContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarENoiseCutWriteKey, ctx);
        gScalarERmsContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarERmsWriteKey, ctx);
 
        ATH_CHECK(gRhoContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gRhoContainer.key());
        ATH_CHECK(gSJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gSJContainer.key());
        ATH_CHECK(gLJContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer with key " << gLJContainer.key());
        ATH_CHECK(gScalarEJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarEJwojContainer.key());
        ATH_CHECK(gMETComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsJwojContainer.key());
        ATH_CHECK(gMHTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMHTComponentsJwojContainer.key());
        ATH_CHECK(gMSTComponentsJwojContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMSTComponentsJwojContainer.key());
        ATH_CHECK(gMETComponentsNoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsNoiseCutContainer.key());
        ATH_CHECK(gMETComponentsRmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gMETComponentsRmsContainer.key());
        ATH_CHECK(gScalarENoiseCutContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarENoiseCutContainer.key());
        ATH_CHECK(gScalarERmsContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gScalarERmsContainer.key());
    }
 
    //---gEspresso Container (always decoded - not in HLT result)
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gEspressoContainer(m_gEspressoWriteKey, ctx);
    ATH_CHECK(gEspressoContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gEspressoContainer.key());
 
    //---gRistretto Container (always decoded - not in HLT result)
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gRistrettoContainer(m_gRistrettoWriteKey, ctx);
    ATH_CHECK(gRistrettoContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
    ATH_MSG_DEBUG("Recorded gFexJetGlobalContainer with key " << gRistrettoContainer.key());
 
    // Determine if multi-slice mode is enabled (slice 0 = L1A, slices 1,2 = out-of-time)
    const bool multiSlice = !m_gFexJetSliceWriteKey.empty();
 
    // Create out-of-time containers for jet TOBs if multi-slice enabled
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gRhoSliceContainer;
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gSJSliceContainer;
    SG::WriteHandle<xAOD::gFexJetRoIContainer> gLJSliceContainer;
    // Create out-of-time containers for global TOBs if multi-slice enabled
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarEJwojSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsJwojSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMHTComponentsJwojSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMSTComponentsJwojSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gEspressoSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gRistrettoSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsNoiseCutSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarENoiseCutSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gMETComponentsRmsSliceContainer;
    SG::WriteHandle<xAOD::gFexGlobalRoIContainer> gScalarERmsSliceContainer;
 
    if (multiSlice) {
        gRhoSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexRhoSliceWriteKey, ctx);
        ATH_CHECK(gRhoSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gRhoSliceContainer.key());
 
        gSJSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexBlockSliceWriteKey, ctx);
        ATH_CHECK(gSJSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gSJSliceContainer.key());
 
        gLJSliceContainer = SG::WriteHandle<xAOD::gFexJetRoIContainer>(m_gFexJetSliceWriteKey, ctx);
        ATH_CHECK(gLJSliceContainer.record(std::make_unique<xAOD::gFexJetRoIContainer>(), std::make_unique<xAOD::gFexJetRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexJetRoIContainer (out-of-time) with key " << gLJSliceContainer.key());
 
        gScalarEJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarEJwojSliceWriteKey, ctx);
        ATH_CHECK(gScalarEJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarEJwojSliceContainer.key());
 
        gMETComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsJwojSliceWriteKey, ctx);
        ATH_CHECK(gMETComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsJwojSliceContainer.key());
 
        gMHTComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMHTComponentsJwojSliceWriteKey, ctx);
        ATH_CHECK(gMHTComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMHTComponentsJwojSliceContainer.key());
 
        gMSTComponentsJwojSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMSTComponentsJwojSliceWriteKey, ctx);
        ATH_CHECK(gMSTComponentsJwojSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMSTComponentsJwojSliceContainer.key());
 
        gEspressoSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gEspressoSliceWriteKey, ctx);
        ATH_CHECK(gEspressoSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gEspressoSliceContainer.key());
 
        gRistrettoSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gRistrettoSliceWriteKey, ctx);
        ATH_CHECK(gRistrettoSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gRistrettoSliceContainer.key());
 
        gMETComponentsNoiseCutSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsNoiseCutSliceWriteKey, ctx);
        ATH_CHECK(gMETComponentsNoiseCutSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsNoiseCutSliceContainer.key());
 
        gScalarENoiseCutSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarENoiseCutSliceWriteKey, ctx);
        ATH_CHECK(gScalarENoiseCutSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarENoiseCutSliceContainer.key());
 
        gMETComponentsRmsSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gMETComponentsRmsSliceWriteKey, ctx);
        ATH_CHECK(gMETComponentsRmsSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gMETComponentsRmsSliceContainer.key());
 
        gScalarERmsSliceContainer = SG::WriteHandle<xAOD::gFexGlobalRoIContainer>(m_gScalarERmsSliceWriteKey, ctx);
        ATH_CHECK(gScalarERmsSliceContainer.record(std::make_unique<xAOD::gFexGlobalRoIContainer>(), std::make_unique<xAOD::gFexGlobalRoIAuxContainer>()));
        ATH_MSG_DEBUG("Recorded gFexGlobalRoIContainer (out-of-time) with key " << gScalarERmsSliceContainer.key());
    }
 
 
    // Iterate over ROBFragments to decode
    for (const ROBF* rob : vrobf) {
        // Iterate over ROD words and decode
        
        
        ATH_MSG_DEBUG("Starting to decode " << rob->rod_ndata() << " ROD words from ROB 0x" << std::hex << rob->rob_source_id());
        
        //There is no data to decode.. not even the ROD trailers
        if(rob->rod_ndata() <= 0){
            continue;
        }
        
        const auto dataArray = std::span{rob->rod_data(), rob->rod_ndata()};
 
        
        // Starting to loop over the gFEX words
 
        unsigned int n_words = rob->rod_ndata();
        // The 2-word ROD trailer at the end of rod_data is not part of the
        // subblock stream; skip it so the parse loop below doesn't read 0/0
        // as a subblock header and spin forever.
        constexpr unsigned int ROD_TRAILER_WORDS = 2;
        if (n_words >= ROD_TRAILER_WORDS) n_words -= ROD_TRAILER_WORDS;
 
        //saving Jet TOBs into the EDM container
        for(unsigned int iWord=0; iWord<n_words; iWord++) {
            ATH_MSG_DEBUG("Raw word  0x" << std::hex << dataArray[iWord]  << "    " << std::bitset<32> (dataArray[iWord]));
        }
        
        // Vectors to temporarily store global tob before they are summed together
        // For multi-slice support, we use vectors of arrays: [sliceNumber][fpga]
        // Vectors are dynamically resized based on the actual number of slices in the data
        // Inner arrays are fixed size 3 (one element per FPGA)
        std::vector<int> global_counter;
        std::vector<std::array<uint32_t, 3>> JWOJ_MHT;
        std::vector<std::array<uint32_t, 3>> JWOJ_MST;
        std::vector<std::array<uint32_t, 3>> JWOJ_MET;
        std::vector<std::array<uint32_t, 3>> JWOJ_SCALAR;
        std::vector<std::array<uint32_t, 3>> GESPRESSO;
        std::vector<std::array<uint32_t, 3>> GRISTRETTO;
        std::vector<std::array<uint32_t, 3>> NC_MET;
        std::vector<std::array<uint32_t, 3>> NC_SCALAR;
        std::vector<std::array<uint32_t, 3>> RMS_MET;
        std::vector<std::array<uint32_t, 3>> RMS_SCALAR;
        // Track slice numbers for global TOBs (to be assigned when fillGlobal is called)
        std::vector<uint32_t> globalSliceNumbers;
 
        // Helper lambda to ensure vectors are large enough for a given slice
        auto ensureSliceCapacity = [&](size_t sliceNum) {
            if (sliceNum >= global_counter.size()) {
                size_t newSize = sliceNum + 1;
                global_counter.resize(newSize, 0);
                JWOJ_MHT.resize(newSize, {0, 0, 0});
                JWOJ_MST.resize(newSize, {0, 0, 0});
                JWOJ_MET.resize(newSize, {0, 0, 0});
                JWOJ_SCALAR.resize(newSize, {0, 0, 0});
                GESPRESSO.resize(newSize, {0, 0, 0});
                GRISTRETTO.resize(newSize, {0, 0, 0});
                NC_MET.resize(newSize, {0, 0, 0});
                NC_SCALAR.resize(newSize, {0, 0, 0});
                RMS_MET.resize(newSize, {0, 0, 0});
                RMS_SCALAR.resize(newSize, {0, 0, 0});
            }
        };
 
        size_t index = 0;
        while ( index < n_words ) {
            const uint32_t headerWord = dataArray[index];//Identify the header words. The first is a header word.
            const uint32_t blockType  = (headerWord >> gPos::BLOCK_TYPE_BIT)  &    gPos::BLOCK_TYPE_MASK;
            const uint32_t headerSize = (headerWord >> gPos::HEADER_SIZE_BIT) &    gPos::HEADER_SIZE_MASK;
            const uint32_t errorFlags = (headerWord >> gPos::ERROR_FLAG_BIT)  &    gPos::ERROR_FLAG_MASK;
            const uint32_t dataSize   =  headerWord        &  gPos::DATA_SIZE_MASK;
      
            ATH_MSG_DEBUG( "index        "<< index );
            ATH_MSG_DEBUG( "word         "<< std::bitset<32> (dataArray[index]) );
            ATH_MSG_DEBUG( "headerWord   "<< std::bitset<32> (headerWord) );
            ATH_MSG_DEBUG( "blockType    "<< std::bitset<4> (blockType) );
            ATH_MSG_DEBUG( "headerSize   "<< std::bitset<2> (headerSize) );
            ATH_MSG_DEBUG( "errorFlags   "<< std::bitset<1> (errorFlags) );
            ATH_MSG_DEBUG( "dataSize     "<< std::bitset<12> (dataSize) );
            
            const uint32_t blockSize  = headerSize + dataSize;
            if ( (index + blockSize) > n_words ) {
                
                std::stringstream sdetail;
                sdetail  << "Remaining block size " << (n_words - index) << " is too small for subblock of type " << blockType << " with headerSize " << headerSize << " and dataSize " << dataSize ;
                std::stringstream slocation;
                slocation  << "0x"<< std::hex << rob->rob_source_id() << std::dec << " type:"<<blockType;
                std::stringstream stitle;
                stitle  << "Small subblock size " ;
                printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());  
                
            }
 
            index += headerSize;
      
            const uint32_t numSlices = dataSize / gPos::WORDS_PER_SLICE;
            ATH_MSG_DEBUG( "numSlices   "  <<  numSlices );
 
            if ( numSlices * gPos::WORDS_PER_SLICE != dataSize ) {
 
                std::stringstream sdetail;
                sdetail  << "L1CaloBsDecoderRun3::decodeGfexTobs: subblock type " << blockType << " with dataSize " << dataSize << " is not a multiple of " << gPos::WORDS_PER_SLICE << " words" ;
                std::stringstream slocation;
                slocation  << "0x"<< std::hex << rob->rob_source_id()<< std::dec << " type:"<<blockType;
                std::stringstream stitle;
                stitle  << "Wrong dataSize" ;
                printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());   
                     
                //skip decode of this fragment
                index+=dataSize;
                continue;
                
            }
 
            // The subblock type is 0xA,B,C for jet TOBs from FPGA A,B,C
            // and 0x1,2,3 for global (MET) TOBs.
            bool isMet = (blockType >= 0x1 && blockType <= 0x3);
            bool isJet = (blockType >= 0xA && blockType <= 0xC);
 
            for (uint32_t sliceNumber = 0; sliceNumber < numSlices; sliceNumber++) {
 
                // Skip out-of-time slices (slice != 0) if multi-slice mode is disabled
                if (sliceNumber != 0 && !multiSlice) {
                    index += gPos::WORDS_PER_SLICE;
                    continue;
                }
 
                if ( !isJet && !isMet ) {
                    std::stringstream sdetail;
                    sdetail  << "gFexByteStreamTool::decodeGfexTobSlice: Invalid block type " << blockType ;
                    std::stringstream slocation;
                    slocation  << "0x"<< std::hex << rob->rob_source_id();
                    std::stringstream stitle;
                    stitle  << "Invalid block type" ;
                    printError(slocation.str(),stitle.str(),MSG::DEBUG,sdetail.str());
                }
 
                // Select target containers based on slice (slice 0 = L1A -> main containers, others -> out-of-time containers)
                auto& targetRhoContainer = (sliceNumber == 0) ? gRhoContainer : gRhoSliceContainer;
                auto& targetSJContainer  = (sliceNumber == 0) ? gSJContainer  : gSJSliceContainer;
                auto& targetLJContainer  = (sliceNumber == 0) ? gLJContainer  : gLJSliceContainer;
 
                for(unsigned int iWord=0; iWord<gPos::WORDS_PER_SLICE; iWord++) {
 
                    // Skip jet TOB fill at slice 0 when standard containers are disabled
                    if (isJet && (sliceNumber != 0 || decodeStdTOBs)) {
                        //Skipping the unused words
                        if (std::find(gPos::JET_UNUSED_POSITION.begin(),gPos::JET_UNUSED_POSITION.end(),iWord)!=gPos::JET_UNUSED_POSITION.end()){
                            continue;
                        }
                        //Skipping the trailer words
                        if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
                            continue;
                        }
                        // Decorator for slice number - only needed for out-of-time containers
                        // (L1A containers by definition only contain slice 0)
                        static const SG::AuxElement::Decorator<uint32_t> sliceNumberDec("sliceNumber");
                        
                        //Saving gRho TOBs into the EDM container
                        if (iWord == gPos::GRHO_POSITION){
                            std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                            targetRhoContainer->push_back(std::move(myEDM));
                            targetRhoContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
                            if (sliceNumber != 0) sliceNumberDec(*targetRhoContainer->back()) = sliceNumber;
                        }
                        //Saving gBlock TOBs into the EDM container
                        if (std::find(gPos::GBLOCK_POSITION.begin(),gPos::GBLOCK_POSITION.end(),iWord)!=gPos::GBLOCK_POSITION.end()){
                            std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                            targetSJContainer->push_back(std::move(myEDM));
                            targetSJContainer->back()->initialize(dataArray[index+iWord], m_gJ_scale);
                            if (sliceNumber != 0) sliceNumberDec(*targetSJContainer->back()) = sliceNumber;
                        }
                        //Saving gJet TOBs into the EDM container
                        if (std::find(gPos::GJET_POSITION.begin(),gPos::GJET_POSITION.end(),iWord)!=gPos::GJET_POSITION.end()){
                            std::unique_ptr<xAOD::gFexJetRoI> myEDM (new xAOD::gFexJetRoI());
                            targetLJContainer->push_back(std::move(myEDM));
                            targetLJContainer->back()->initialize(dataArray[index+iWord], m_gLJ_scale);
                            if (sliceNumber != 0) sliceNumberDec(*targetLJContainer->back()) = sliceNumber;
                        }
 
                    }
 
                    // Global TOBs - decode for all slices, store per-slice data
                    // They require data from all 3 FPGAs to be combined later
                    if (isMet){
                        // Ensure we have storage for this slice
                        ensureSliceCapacity(sliceNumber);
 
                        //Skipping the unused words
                        if (std::find(gPos::GLOBAL_UNUSED_POSITION.begin(),gPos::GLOBAL_UNUSED_POSITION.end(),iWord)!=gPos::GLOBAL_UNUSED_POSITION.end()){
                            continue;
                        }
                        //Skipping the trailer words
                        if (std::find(gPos::TRAILER_POSITION.begin(),gPos::TRAILER_POSITION.end(),iWord)!=gPos::TRAILER_POSITION.end()){
                            continue;
                        }
                        //Saving jwoj MHT TOBs into the EDM container
                        if (iWord == gPos::JWOJ_MHT_POSITION){
                            global_counter[sliceNumber]++;
                            if (blockType == 0x1) {JWOJ_MHT[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {JWOJ_MHT[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {JWOJ_MHT[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving jwoj MST TOBs into the EDM container
                        if (iWord == gPos::JWOJ_MST_POSITION){
                            if (blockType == 0x1) {JWOJ_MST[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {JWOJ_MST[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {JWOJ_MST[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving jwoj MET TOBs into the EDM container
                        if (iWord == gPos::JWOJ_MET_POSITION){
                            if (blockType == 0x1) {JWOJ_MET[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {JWOJ_MET[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {JWOJ_MET[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving jwoj Scalar TOBs into the EDM container
                        if (iWord == gPos::JWOJ_SCALAR_POSITION){
                            if (blockType == 0x1) {JWOJ_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {JWOJ_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {JWOJ_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving gEspresso TOBs into the EDM container
                        if (iWord == gPos::GESPRESSO_POSITION){
                            if (blockType == 0x1) {GESPRESSO[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {GESPRESSO[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {GESPRESSO[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving gRistretto TOBs into the EDM container
                        if (iWord == gPos::GRISTRETTO_POSITION){
                            if (blockType == 0x1) {GRISTRETTO[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {GRISTRETTO[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {GRISTRETTO[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving Noise Cut MET TOBs into the EDM container
                        if (iWord == gPos::NC_MET_POSITION){
                            if (blockType == 0x1) {NC_MET[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {NC_MET[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {NC_MET[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving Noise Cut Scalar TOBs into the EDM container
                        if (iWord == gPos::NC_SCALAR_POSITION){
                            if (blockType == 0x1) {NC_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {NC_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {NC_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving Rho+RMS MET TOBs into the EDM container
                        if (iWord == gPos::RMS_MET_POSITION){
                            if (blockType == 0x1) {RMS_MET[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {RMS_MET[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {RMS_MET[sliceNumber][2] = dataArray[index+iWord];}
                        }
                        //Saving Rho+RMS Scalar TOBs into the EDM container
                        if (iWord == gPos::RMS_SCALAR_POSITION){
                            if (blockType == 0x1) {RMS_SCALAR[sliceNumber][0] = dataArray[index+iWord];}
                            if (blockType == 0x2) {RMS_SCALAR[sliceNumber][1] = dataArray[index+iWord];}
                            if (blockType == 0x3) {RMS_SCALAR[sliceNumber][2] = dataArray[index+iWord];}
                        }
 
                    }
 
                }
 
                index += gPos::WORDS_PER_SLICE;
            }
 
            // Fill global TOBs for each slice that has complete data from all 3 FPGAs
            for (size_t slice = 0; slice < global_counter.size(); slice++) {
                ATH_MSG_DEBUG("global_counter[" << slice << "] is " << global_counter[slice]);
                if (global_counter[slice] == 3) {
                    // Skip out-of-time slices if multi-slice mode is disabled
                    if (slice != 0 && !multiSlice) {
                        global_counter[slice] = 0;
                        continue;
                    }
 
                    // Select target containers based on slice (slice 0 = L1A, others = out-of-time)
                    if (slice == 0 && !decodeStdTOBs) {
                        // Only fill gEspresso and gRistretto when standard TOBs are disabled
                        fillGlobal(GESPRESSO[slice], 1, gEspressoContainer, slice, 0);
                        fillGlobal(GRISTRETTO[slice], 1, gRistrettoContainer, slice, 0);
                    } else {
                    auto& targetMHTContainer = (slice == 0) ? gMHTComponentsJwojContainer : gMHTComponentsJwojSliceContainer;
                    auto& targetMSTContainer = (slice == 0) ? gMSTComponentsJwojContainer : gMSTComponentsJwojSliceContainer;
                    auto& targetMETContainer = (slice == 0) ? gMETComponentsJwojContainer : gMETComponentsJwojSliceContainer;
                    auto& targetScalarContainer = (slice == 0) ? gScalarEJwojContainer : gScalarEJwojSliceContainer;
                    auto& targetEspressoContainer = (slice == 0) ? gEspressoContainer : gEspressoSliceContainer;
                    auto& targetRistrettoContainer = (slice == 0) ? gRistrettoContainer : gRistrettoSliceContainer;
                    auto& targetNCMETContainer = (slice == 0) ? gMETComponentsNoiseCutContainer : gMETComponentsNoiseCutSliceContainer;
                    auto& targetNCScalarContainer = (slice == 0) ? gScalarENoiseCutContainer : gScalarENoiseCutSliceContainer;
                    auto& targetRMSMETContainer = (slice == 0) ? gMETComponentsRmsContainer : gMETComponentsRmsSliceContainer;
                    auto& targetRMSScalarContainer = (slice == 0) ? gScalarERmsContainer : gScalarERmsSliceContainer;
 
                    fillGlobal(JWOJ_MHT[slice], 3, targetMHTContainer, slice);
                    fillGlobal(JWOJ_MST[slice], 4, targetMSTContainer, slice);
                    int16_t scalar = fillGlobal(JWOJ_MET[slice], 2, targetMETContainer, slice);
                    fillGlobal(JWOJ_SCALAR[slice], 1, targetScalarContainer, slice, scalar);
 
                    fillGlobal(GESPRESSO[slice], 1, targetEspressoContainer, slice, 0);
 
                    fillGlobal(GRISTRETTO[slice], 1, targetRistrettoContainer, slice, 0);
 
                    scalar = fillGlobal(NC_MET[slice], 2, targetNCMETContainer, slice);
                    fillGlobal(NC_SCALAR[slice], 1, targetNCScalarContainer, slice, scalar);
 
                    scalar = fillGlobal(RMS_MET[slice], 2, targetRMSMETContainer, slice);
                    fillGlobal(RMS_SCALAR[slice], 1, targetRMSScalarContainer, slice, scalar);
                    } // end else (standard TOBs enabled or out-of-time slice)
 
                    global_counter[slice] = 0;
                }
            }
            
        }
    }
    return StatusCode::SUCCESS;
} 
 
// For MHT, MST, and MET, it sums the x and y components across FPGAs, and also returnes
// the sum in quadrature (which is actually only used for MET, and discared for MHT and MST)
// This function also accepts "scalar" as optional variable, which is used to fill the X
// component of the SCALAR tob.
int16_t gFexByteStreamTool::fillGlobal(const std::array<uint32_t, 3> &tob, const int type,
                                       SG::WriteHandle<xAOD::gFexGlobalRoIContainer> &container,
                                       uint32_t sliceNumber, int16_t scalar/* = -1*/) const {
    
    ATH_MSG_DEBUG("fillGlobal with type " << type << " slice " << sliceNumber);
    
    // 32 bit integers to avoid interim overflows when summing 16b (signed) 
    // quantities from each pFPGA. Proper clamping and bit masking follows afterwards
    int32_t sum_x = 0;
    int32_t sum_y = 0;
 
    // Extract the x and y components and sum them for the three FPGAs
    for (size_t fpga = 0; fpga < 3; fpga++) {
        int16_t x = tob[fpga] >> gPos::GLOBAL_X_BIT & gPos::GLOBAL_X_MASK;
        int16_t y = tob[fpga] >> gPos::GLOBAL_Y_BIT & gPos::GLOBAL_Y_MASK;
        if (x & 0x00080000) { x  = 0xFFFF0000 | x;  }
        if (y & 0x00080000) { y  = 0xFFFF0000 | y;  }
        sum_x += x;
        if (container.key() == "L1_gScalarEJwoj" && y < 0) y = 0;
        sum_y += y;
    }
 
    // Special case for gEspresso/gRistretto: in the readout these quantities are stored in x. We need to move them to y to armonize this with the other scalar quantities
    // This is true for the readout only. On the realtime path gEspresso is sent to Topo on y (see https://docs.google.com/spreadsheets/d/15YVVtGofhXMtV7jXRFzWO0FVUtUAjS-X-aQjh3FKE_w/edit?gid=1546010783#gid=1546010783).
    if  (container.key() == "L1_gEspresso" || container.key() == "L1_gRistretto" ) {
        sum_y = sum_x; 
    }
 
    if (type == 1) {//we are considering the scalar case (sum_x = MET and sum_y = SumEt) 
        ATH_MSG_DEBUG("  scalar tob, saving " << scalar << " in X component");
        sum_x = scalar; //Total MET
        if( sum_y > 0x000FFF) sum_y = 0x000FFF; //Overflow control for SumEt
        if( sum_y < 0) sum_y = 0;
 
    } else {
        if (sum_x < -0x000800) sum_x = -0x000800; //-2048
        if (sum_x > 0x0007FF) sum_x  = 0x0007FF; //2047
 
        if (sum_y < -0x000800) sum_y = -0x000800; //-2048
        if (sum_y > 0x0007FF) sum_y  = 0x0007FF; //2047
    }
 
    ATH_MSG_DEBUG("  fillGlobal type " << type << std::dec << " sum_x " << sum_x << " sum_y " << sum_y);
 
    uint32_t METword = 0;
 
    METword = (sum_y &  0x00000FFF) << 0; //set the Quantity2 to the corresponding slot (LSB)
    METword = METword | (sum_x  &  0x00000FFF) << 12;//Quantity 1 (in bit number 12)
    if (sum_y != 0) METword = METword | 0x00000001 << 24;//Status bit for Quantity 2 (0 if quantity is null)
    if (sum_x != 0) METword = METword | 0x00000001 << 25;//Status bit for Quantity 1 (0 if quantity is null)
    METword = METword | (type  &  0x0000001F) << 26;//TOB ID (5 bits starting at 26)
 
    // Save to the EDM
    std::unique_ptr<xAOD::gFexGlobalRoI> myEDM (new xAOD::gFexGlobalRoI());
    container->push_back(std::move(myEDM));
    container->back()->setWord(METword);
    container->back()->setQuantityOne(sum_x);
    container->back()->setQuantityTwo(sum_y);
    container->back()->setScaleOne(m_gXE_scale);
    container->back()->setScaleTwo(m_gTE_scale);
    container->back()->setStatusOne(1);
    container->back()->setStatusTwo(1);
    container->back()->setSaturated(0);
    container->back()->setGlobalType(type);
    
    // Add slice number decoration only for out-of-time TOBs
    // (L1A containers by definition only contain slice 0)
    if (sliceNumber != 0) {
        static const SG::AuxElement::Decorator<uint32_t> sliceNumberDec("sliceNumber");
        sliceNumberDec(*container->back()) = sliceNumber;
    }
 
    int MET2 = sum_x * sum_x + sum_y * sum_y;
    int16_t MET = std::sqrt(MET2);
    if (MET > 0x000FFF) MET = 0x000FFF;
 
    return MET;
 
}
 

uint32_t gFexByteStreamTool::buildBlockHeader(uint32_t blockType, uint32_t numSlices) const {
    constexpr uint32_t headerSize = 1;
    constexpr uint32_t errorFlag  = 0;
    const     uint32_t dataSize   = numSlices * gPos::WORDS_PER_SLICE;
    return ((blockType  & gPos::BLOCK_TYPE_MASK ) << gPos::BLOCK_TYPE_BIT )
         | ((headerSize & gPos::HEADER_SIZE_MASK) << gPos::HEADER_SIZE_BIT)
         | ((errorFlag  & gPos::ERROR_FLAG_MASK ) << gPos::ERROR_FLAG_BIT )
         | ( dataSize   & gPos::DATA_SIZE_MASK  );
}

StatusCode gFexByteStreamTool::convertToBS(std::vector<WROBF*>& vrobf,
                                           const xAOD::TrigCompositeContainer* tc,
                                           const EventContext& eventContext) {
 
    NamedContainerMap<xAOD::gFexJetRoIContainer>    jetMap;
    NamedContainerMap<xAOD::gFexGlobalRoIContainer> globalMap;
    if (tc && !tc->empty()) {
        const xAOD::TrigComposite& l1 = *tc->at(0);
        jetMap    = indexByName<xAOD::gFexJetRoIContainer   >(l1);
        globalMap = indexByName<xAOD::gFexGlobalRoIContainer>(l1);
    }
 
    constexpr uint32_t numSlices = 1; // slice 0 = L1A; out-of-time slices not emitted in v1
    std::vector<uint32_t> words;
    words.reserve(6 * (1 + numSlices * gPos::WORDS_PER_SLICE) + 2);
 
    // Shared across both subblock loops; reset to 0 at the start of each iteration.
    std::array<uint32_t, gPos::WORDS_PER_SLICE> slice{};
 
    // ---- Jet subblocks: blockType 0xA / 0xB / 0xC for FPGA A / B / C ----
    // The xAOD gBlock / gJet / gRho containers concatenate all three FPGAs' TOBs;
    // we slice them back deterministically (TOBs 0..3 -> FPGA-A pos 1,2,8,9, etc.)
    // so a decode -> encode -> decode cycle reproduces the original xAOD content.
    constexpr std::array<uint32_t, 3> jetBlockTypes = {0xA, 0xB, 0xC};
    for (uint32_t fpga = 0; fpga < 3; ++fpga) {
        slice.fill(0);
        words.push_back(buildBlockHeader(jetBlockTypes[fpga], numSlices));
        for (size_t s = 0; s < gPos::GBLOCK_POSITION.size(); ++s) {
            slice[gPos::GBLOCK_POSITION[s]] =
                wordAtOrZero(jetMap, "L1_gFexSRJetRoI",
                             fpga * gPos::GBLOCK_POSITION.size() + s);
        }
        for (size_t s = 0; s < gPos::GJET_POSITION.size(); ++s) {
            slice[gPos::GJET_POSITION[s]] =
                wordAtOrZero(jetMap, "L1_gFexLRJetRoI",
                             fpga * gPos::GJET_POSITION.size() + s);
        }
        slice[gPos::GRHO_POSITION] = wordAtOrZero(jetMap, "L1_gFexRhoRoI", fpga);
        // Trailer (pos 6, 13) and unused (pos 0, 4, 5, 11, 12) stay 0: the
        // decoder skips both groups, so any value would be discarded anyway.
        for (uint32_t w : slice) words.push_back(w);
    }
 
    // ---- Global subblocks: blockType 0x1 / 0x2 / 0x3 for FPGA A / B / C ----
    // Each xAOD Global RoI carries the sum across the three FPGAs in its word();
    // we place that sum in the FPGA-A slot and leave FPGA-B/C zero so the decoder's
    // sum across blockType 0x1 + 0x2 + 0x3 reproduces the xAOD value exactly.
    constexpr std::array<uint32_t, 3> globalBlockTypes = {0x1, 0x2, 0x3};
    for (uint32_t fpga = 0; fpga < 3; ++fpga) {
        slice.fill(0);
        words.push_back(buildBlockHeader(globalBlockTypes[fpga], numSlices));
        if (fpga == 0) {
            // Vector components (signed 12-bit, can be negative)
            slice[gPos::JWOJ_MHT_POSITION]    = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gMHTComponentsJwoj"),       /*signed12bit=*/true);
            slice[gPos::JWOJ_MST_POSITION]    = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gMSTComponentsJwoj"),       /*signed12bit=*/true);
            slice[gPos::JWOJ_MET_POSITION]    = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gMETComponentsJwoj"),       /*signed12bit=*/true);
            slice[gPos::NC_MET_POSITION]      = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gMETComponentsNoiseCut"),   /*signed12bit=*/true);
            slice[gPos::RMS_MET_POSITION]     = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gMETComponentsRms"),        /*signed12bit=*/true);
            // Scalar energies (unsigned 12-bit, decoder clamps to [0, 0xFFF])
            slice[gPos::JWOJ_SCALAR_POSITION] = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gScalarEJwoj"),              /*signed12bit=*/false);
            slice[gPos::GRISTRETTO_POSITION]  = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gRistretto"),                /*signed12bit=*/false);
            slice[gPos::GESPRESSO_POSITION]   = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gEspresso"),                 /*signed12bit=*/false);
            slice[gPos::NC_SCALAR_POSITION]   = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gScalarENoiseCut"),          /*signed12bit=*/false);
            slice[gPos::RMS_SCALAR_POSITION]  = globalRoIWordToPerFpgaTob(firstWord(globalMap, "L1_gScalarERms"),               /*signed12bit=*/false);
        }
        for (uint32_t w : slice) words.push_back(w);
    }
 
    ATH_MSG_DEBUG("gFex encoder: jetContainers=" << jetMap.size()
                  << " globalContainers=" << globalMap.size()
                  << " words=" << words.size());
 
    // ROD trailer (decoder only reads the 7-bit error flag in word1 -- write 0/0)
    words.push_back(0);
    words.push_back(0);
 
    clearCache(eventContext);
    uint32_t* data = newRodData(eventContext, words.size());
    std::copy(words.begin(), words.end(), data);
 
    // gFex packs all 6 subblocks (3 Jet + 3 Global) into a single ROB.
    eformat::helper::SourceIdentifier sid(eformat::TDAQ_CALO_FEAT_EXTRACT_ROI, 0x3000);
    vrobf.push_back(newRobFragment(eventContext, sid.code(), words.size(), data, 0));
 
    return StatusCode::SUCCESS;
}
 
 
void  gFexByteStreamTool::printError(const std::string& location, const std::string& title, MSG::Level type, const std::string& detail) const{
    
    if(m_UseMonitoring){
        Monitored::Group(m_monTool,
                     Monitored::Scalar("gfexDecoderErrorLocation",location.empty() ? std::string("UNKNOWN") : location),
                     Monitored::Scalar("gfexDecoderErrorTitle"   ,title.empty()    ? std::string("UNKNOWN") : title)
                     );
    }
    else {
        msg() << type << detail << endmsg;
    }
}