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;
 
gFexByteStreamTool::gFexByteStreamTool(const std::string& type,
        const std::string& name,
        const IInterface* parent)
    : base_class(type, name, parent) {}
 
StatusCode gFexByteStreamTool::initialize() {
    // Conversion mode for gRho TOBs
    ATH_MSG_DEBUG(" ROB IDs: " << MSG::hex << m_robIds.value() << MSG::dec);
 
    // When both read and write keys are empty for standard containers, they are disabled.
    // This happens in TOBs=False mode: standard L1A containers come from the HLT result
    // and only gEspresso/gRistretto/OutOfTime containers are decoded from the L1 ROB.
    const bool stdTOBsEnabled = !m_gFexRhoReadKey.key().empty() || !m_gFexRhoWriteKey.key().empty();
 
    ConversionMode gRhomode = ConversionMode::Undefined;
    ConversionMode gSJmode = ConversionMode::Undefined;
    ConversionMode gLJmode = ConversionMode::Undefined;
 
    if (stdTOBsEnabled) {
        gRhomode = getConversionMode(m_gFexRhoReadKey, m_gFexRhoWriteKey, msg());
        ATH_CHECK(gRhomode!=ConversionMode::Undefined);
        ATH_CHECK(m_gFexRhoWriteKey.initialize(gRhomode==ConversionMode::Decoding));
        ATH_CHECK(m_gFexRhoReadKey.initialize(gRhomode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gRhomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gRho ");
 
        gSJmode = getConversionMode(m_gFexBlockReadKey, m_gFexBlockWriteKey, msg());
        ATH_CHECK(gSJmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gFexBlockWriteKey.initialize(gSJmode==ConversionMode::Decoding));
        ATH_CHECK(m_gFexBlockReadKey.initialize(gSJmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gSJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gSJ ");
 
        gLJmode = getConversionMode(m_gFexJetReadKey, m_gFexJetWriteKey, msg());
        ATH_CHECK(gLJmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gFexJetWriteKey.initialize(gLJmode==ConversionMode::Decoding));
        ATH_CHECK(m_gFexJetReadKey.initialize(gLJmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gLJmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gLJ ");
 
        ConversionMode gScalarEJwojmode = getConversionMode(m_gScalarEJwojReadKey, m_gScalarEJwojWriteKey, msg());
        ATH_CHECK(gScalarEJwojmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gScalarEJwojWriteKey.initialize(gScalarEJwojmode==ConversionMode::Decoding));
        ATH_CHECK(m_gScalarEJwojReadKey.initialize(gScalarEJwojmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gScalarEJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarEJwoj ");
 
        ConversionMode gMETComponentsJwojmode = getConversionMode(m_gMETComponentsJwojReadKey, m_gMETComponentsJwojWriteKey, msg());
        ATH_CHECK(gMETComponentsJwojmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gMETComponentsJwojWriteKey.initialize(gMETComponentsJwojmode==ConversionMode::Decoding));
        ATH_CHECK(m_gMETComponentsJwojReadKey.initialize(gMETComponentsJwojmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gMETComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsJwoj ");
 
        ConversionMode gMHTComponentsJwojmode = getConversionMode(m_gMHTComponentsJwojReadKey, m_gMHTComponentsJwojWriteKey, msg());
        ATH_CHECK(gMHTComponentsJwojmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gMHTComponentsJwojWriteKey.initialize(gMHTComponentsJwojmode==ConversionMode::Decoding));
        ATH_CHECK(m_gMHTComponentsJwojReadKey.initialize(gMHTComponentsJwojmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gMHTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMHTComponentsJwoj ");
 
        ConversionMode gMSTComponentsJwojmode = getConversionMode(m_gMSTComponentsJwojReadKey, m_gMSTComponentsJwojWriteKey, msg());
        ATH_CHECK(gMSTComponentsJwojmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gMSTComponentsJwojWriteKey.initialize(gMSTComponentsJwojmode==ConversionMode::Decoding));
        ATH_CHECK(m_gMSTComponentsJwojReadKey.initialize(gMSTComponentsJwojmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gMSTComponentsJwojmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMSTComponentsJwoj ");
 
        ConversionMode gMETComponentsNoiseCutmode = getConversionMode(m_gMETComponentsNoiseCutReadKey, m_gMETComponentsNoiseCutWriteKey, msg());
        ATH_CHECK(gMETComponentsNoiseCutmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gMETComponentsNoiseCutWriteKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Decoding));
        ATH_CHECK(m_gMETComponentsNoiseCutReadKey.initialize(gMETComponentsNoiseCutmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gMETComponentsNoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsNoiseCut ");
 
        ConversionMode gMETComponentsRmsmode = getConversionMode(m_gMETComponentsRmsReadKey, m_gMETComponentsRmsWriteKey, msg());
        ATH_CHECK(gMETComponentsRmsmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gMETComponentsRmsWriteKey.initialize(gMETComponentsRmsmode==ConversionMode::Decoding));
        ATH_CHECK(m_gMETComponentsRmsReadKey.initialize(gMETComponentsRmsmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gMETComponentsRmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gMETComponentsRms ");
 
        ConversionMode gScalarENoiseCutmode = getConversionMode(m_gScalarENoiseCutReadKey, m_gScalarENoiseCutWriteKey, msg());
        ATH_CHECK(gScalarENoiseCutmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gScalarENoiseCutWriteKey.initialize(gScalarENoiseCutmode==ConversionMode::Decoding));
        ATH_CHECK(m_gScalarENoiseCutReadKey.initialize(gScalarENoiseCutmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gScalarENoiseCutmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarENoiseCut ");
 
        ConversionMode gScalarERmsmode = getConversionMode(m_gScalarERmsReadKey, m_gScalarERmsWriteKey, msg());
        ATH_CHECK(gScalarERmsmode!=ConversionMode::Undefined);
        ATH_CHECK(m_gScalarERmsWriteKey.initialize(gScalarERmsmode==ConversionMode::Decoding));
        ATH_CHECK(m_gScalarERmsReadKey.initialize(gScalarERmsmode==ConversionMode::Encoding));
        ATH_MSG_DEBUG((gScalarERmsmode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gScalarERms ");
 
        //checking all Conversion modes.. avoid misconfigurations
        const std::array<ConversionMode,2> modes{gSJmode,gLJmode};
        if (std::any_of(modes.begin(),modes.end(),[&gRhomode](ConversionMode m) { return m!=gRhomode;  } )) {
            ATH_MSG_ERROR("Inconsistent conversion modes");
            return StatusCode::FAILURE;
        }
    } else {
        // Standard L1A containers disabled (decoded from HLT result instead)
        ATH_MSG_INFO("Standard L1A gFex TOB containers disabled (decoded from HLT result)");
        ATH_CHECK(m_gFexRhoWriteKey.initialize(false));
        ATH_CHECK(m_gFexRhoReadKey.initialize(false));
        ATH_CHECK(m_gFexBlockWriteKey.initialize(false));
        ATH_CHECK(m_gFexBlockReadKey.initialize(false));
        ATH_CHECK(m_gFexJetWriteKey.initialize(false));
        ATH_CHECK(m_gFexJetReadKey.initialize(false));
        ATH_CHECK(m_gScalarEJwojWriteKey.initialize(false));
        ATH_CHECK(m_gScalarEJwojReadKey.initialize(false));
        ATH_CHECK(m_gMETComponentsJwojWriteKey.initialize(false));
        ATH_CHECK(m_gMETComponentsJwojReadKey.initialize(false));
        ATH_CHECK(m_gMHTComponentsJwojWriteKey.initialize(false));
        ATH_CHECK(m_gMHTComponentsJwojReadKey.initialize(false));
        ATH_CHECK(m_gMSTComponentsJwojWriteKey.initialize(false));
        ATH_CHECK(m_gMSTComponentsJwojReadKey.initialize(false));
        ATH_CHECK(m_gMETComponentsNoiseCutWriteKey.initialize(false));
        ATH_CHECK(m_gMETComponentsNoiseCutReadKey.initialize(false));
        ATH_CHECK(m_gMETComponentsRmsWriteKey.initialize(false));
        ATH_CHECK(m_gMETComponentsRmsReadKey.initialize(false));
        ATH_CHECK(m_gScalarENoiseCutWriteKey.initialize(false));
        ATH_CHECK(m_gScalarENoiseCutReadKey.initialize(false));
        ATH_CHECK(m_gScalarERmsWriteKey.initialize(false));
        ATH_CHECK(m_gScalarERmsReadKey.initialize(false));
    }
 
    // gEspresso and gRistretto are always enabled (not provided by HLT result)
    ConversionMode gEspressomode = getConversionMode(m_gEspressoReadKey, m_gEspressoWriteKey, msg());
    ATH_CHECK(gEspressomode!=ConversionMode::Undefined);
    ATH_CHECK(m_gEspressoWriteKey.initialize(gEspressomode==ConversionMode::Decoding));
    ATH_CHECK(m_gEspressoReadKey.initialize(gEspressomode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gEspressomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gEspresso ");
 
    ConversionMode gRistrettomode = getConversionMode(m_gRistrettoReadKey, m_gRistrettoWriteKey, msg());
    ATH_CHECK(gRistrettomode!=ConversionMode::Undefined);
    ATH_CHECK(m_gRistrettoWriteKey.initialize(gRistrettomode==ConversionMode::Decoding));
    ATH_CHECK(m_gRistrettoReadKey.initialize(gRistrettomode==ConversionMode::Encoding));
    ATH_MSG_DEBUG((gRistrettomode==ConversionMode::Encoding ? "Encoding" : "Decoding") << " gRistretto ");
 
    // 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();
 
        //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;
 
}
 

StatusCode gFexByteStreamTool::convertToBS(std::vector<WROBF*>& /*vrobf*/,
                                           const xAOD::TrigCompositeContainer* /*tc*/,
                                           const EventContext& /*eventContext*/) {
 
    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;
    }
}