L1TriggerResultByteStreamCnv.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// Trigger includes
#include "L1TriggerResultByteStreamCnv.h"
#include "xAODTrigger/TrigCompositeContainer.h"
#include "CTPResultByteStreamTool.h"
 
// Athena includes
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaKernel/ClassID_traits.h"
#include "AthenaKernel/StorableConversions.h"
#include "ByteStreamCnvSvcBase/ByteStreamAddress.h"
 
// Gaudi includes
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
// TDAQ includes
#include "eformat/Issue.h"
#include "eformat/SourceIdentifier.h"
 
using WROBF = OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment;
 
// =============================================================================
// Standard constructor
// =============================================================================
L1TriggerResultByteStreamCnv::L1TriggerResultByteStreamCnv(ISvcLocator* svcLoc) :
  Converter(storageType(), classID(), svcLoc),
  AthMessaging(msgSvc(), "L1TriggerResultByteStreamCnv") {}
 
// =============================================================================
// Standard destructor
// =============================================================================
L1TriggerResultByteStreamCnv::~L1TriggerResultByteStreamCnv() {}
 
// =============================================================================
// Implementation of Converter::initialize
// =============================================================================
StatusCode L1TriggerResultByteStreamCnv::initialize() {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  ATH_CHECK(m_ByteStreamEventAccess.retrieve());
 
  // Check one property of the encoder tools to determine if the tools are configured in the job
  const bool doMuon = not serviceLocator()->getOptsSvc().get("ToolSvc.L1MuonBSEncoderTool.ROBIDs").empty();
  ATH_MSG_DEBUG("MUCTPI BS encoding is " << (doMuon ? "enabled" : "disabled"));
  ATH_CHECK(m_muonEncoderTool.retrieve(EnableTool(doMuon)));
 
  const bool doMuonDaq = not serviceLocator()->getOptsSvc().get("ToolSvc.L1MuonBSEncoderToolDAQ.ROBIDs").empty();
  ATH_MSG_DEBUG("MUCTPI DAQ ROB encoding is " << (doMuonDaq ? "enabled" : "disabled"));
  ATH_CHECK(m_muonEncoderToolDaq.retrieve(EnableTool(doMuonDaq)));
 
  const bool doCTP = not serviceLocator()->getOptsSvc().get("ToolSvc.CTPResultBSEncoderTool.ROBIDs").empty();
  ATH_MSG_DEBUG("CTP BS encoding is " << (doCTP ? "enabled" : "disabled"));
  ATH_CHECK(m_ctpResultEncoderTool.retrieve(EnableTool(doCTP)));
 
  const bool doEfex = not serviceLocator()->getOptsSvc().get("ToolSvc.eFexBSEncoderTool.ROBIDs").empty();
  ATH_MSG_DEBUG("eFex BS encoding is " << (doEfex ? "enabled" : "disabled"));
  ATH_CHECK(m_efexEncoderTool.retrieve(EnableTool(doEfex)));
 
  const bool doJfex = not serviceLocator()->getOptsSvc().get("ToolSvc.jFexBSEncoderTool.ROBIDs").empty();
  ATH_MSG_DEBUG("jFex BS encoding is " << (doJfex ? "enabled" : "disabled"));
  ATH_CHECK(m_jfexEncoderTool.retrieve(EnableTool(doJfex)));
 
  const bool doGfex = not serviceLocator()->getOptsSvc().get("ToolSvc.gFexBSEncoderTool.ROBIDs").empty();
  ATH_MSG_DEBUG("gFex BS encoding is " << (doGfex ? "enabled" : "disabled"));
  ATH_CHECK(m_gfexEncoderTool.retrieve(EnableTool(doGfex)));
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}
 
// =============================================================================
// Implementation of Converter::finalize
// =============================================================================
StatusCode L1TriggerResultByteStreamCnv::finalize() {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
  if (m_ByteStreamEventAccess.release().isFailure())
    ATH_MSG_WARNING("Failed to release service " << m_ByteStreamEventAccess.typeAndName());
  if (m_muonEncoderTool.isEnabled() && m_muonEncoderTool.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_muonEncoderTool.typeAndName());
  if (m_muonEncoderToolDaq.isEnabled() && m_muonEncoderToolDaq.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_muonEncoderToolDaq.typeAndName());
  if (m_ctpResultEncoderTool.isEnabled() && m_ctpResultEncoderTool.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_ctpResultEncoderTool.typeAndName());
  if (m_efexEncoderTool.isEnabled() && m_efexEncoderTool.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_efexEncoderTool.typeAndName());
  if (m_jfexEncoderTool.isEnabled() && m_jfexEncoderTool.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_jfexEncoderTool.typeAndName());
  if (m_gfexEncoderTool.isEnabled() && m_gfexEncoderTool.release().isFailure())
    ATH_MSG_WARNING("Failed to release tool " << m_gfexEncoderTool.typeAndName());
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}
 
// =============================================================================
// Implementation of Converter::createObj
// =============================================================================
StatusCode L1TriggerResultByteStreamCnv::createObj(IOpaqueAddress* /*pAddr*/, DataObject*& /*pObj*/) {
  ATH_MSG_ERROR("L1TriggerResult cannot be created directly from ByteStream!"
                << " Use the L1TriggerResultMaker algorithm instead");
  return StatusCode::FAILURE;
}
 
// =============================================================================
// Implementation of Converter::createRep
// =============================================================================
StatusCode L1TriggerResultByteStreamCnv::createRep(DataObject* pObj, IOpaqueAddress*& pAddr) {
  ATH_MSG_VERBOSE("start of " << __FUNCTION__);
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Cast the DataObject to L1TriggerResult
  xAOD::TrigCompositeContainer* l1TriggerResult = nullptr;
  bool castSuccessful = SG::fromStorable(pObj, l1TriggerResult);
  if (!castSuccessful || !l1TriggerResult) {
    ATH_MSG_ERROR("Failed to convert DataObject to xAOD::TrigCompositeContainer for L1TriggerResult");
    return StatusCode::FAILURE;
  }
 
  // Obtain the RawEventWrite (aka eformat::write::FullEventFragment) pointer
  RawEventWrite* re = m_ByteStreamEventAccess->getRawEvent();
  if (!re) {
    ATH_MSG_ERROR("Failed to obtain a pointer to RawEventWrite");
    return StatusCode::FAILURE;
  }
  ATH_MSG_VERBOSE("Obtained RawEventWrite pointer = " << re);
 
  //  ===== CTPResult encoding =================
 
  // Only perform encoding if tool was enabled, hence only when xAOD::CTPResult is used instead of ROIB::CTPResult (as part of ROIB::RoIBResult)
  if (m_ctpResultEncoderTool.isEnabled()) {
 
    // Extract the CTPResult SG key stored as a detail of the TrigComposite
    const xAOD::TrigComposite* l1tr = l1TriggerResult->at(0);
    std::string ctpKey;
    l1tr->getDetail<std::string>("CTPResultKey", ctpKey);
 
    // Use the retrieved key to read the CTPResult from the event store
    SG::ReadHandle<xAOD::CTPResult> result(ctpKey, ctx);
    ATH_CHECK(result.isValid());
 
    // Helpful lambda function to convert from vectors of 32-bit words to bitsets
    auto wordsToBitset = [](const std::vector<uint32_t>& words) {
        std::bitset<512> out;
        for (size_t i = 0; i < words.size(); ++i) {
            uint32_t w = words[i];
            for (size_t b = 0; b < 32; ++b) {
                if (w & (1u << b)) {
                    out.set(i * 32 + b);
                }
            }
        }
        return out;
    };
 
    std::bitset<512> tbp = wordsToBitset(result->getTBPWords());
    std::bitset<512> tap = wordsToBitset(result->getTAPWords());
    std::bitset<512> tav = wordsToBitset(result->getTAVWords());
 
    // Number of L1 words computed from TBP/TAP/TAV
    constexpr size_t wordSize = 32;
    constexpr size_t wordsPerSet = 512 / wordSize;
    constexpr size_t numWords = 3 * wordsPerSet;
 
    // Allocate per-event storage
    std::vector<uint32_t> l1BitsData(numWords, 0);
 
    // Fill l1BitsData from TBP/TAP/TAV
    size_t iset{0};
    for (const std::bitset<512>& bset : {tbp, tap, tav}) {
        const std::string sbits = bset.to_string();
        const size_t iWordOutputStart = wordsPerSet * iset;
        for (size_t iWordInSet = 0; iWordInSet < wordsPerSet; ++iWordInSet) {
            const size_t bwordPos = 512 - (iWordInSet + 1) * wordSize;
            std::bitset<wordSize> bword{sbits.substr(bwordPos, wordSize)};
            l1BitsData[iWordOutputStart + iWordInSet] = static_cast<uint32_t>(bword.to_ulong());
        }
        ++iset;
    }
    const uint32_t triggerType = result->triggerType();
 
    // Update RawEventWrite
    re->lvl1_trigger_info(l1BitsData.size(), l1BitsData.data());
    re->lvl1_trigger_type(static_cast<uint8_t>(triggerType & 0xFF));
 
  // Check there is no CTPResult ReadHandleKey in the L1TriggerResult when CTP bytestream encoding tool is not enabled
  } else {
    const xAOD::TrigComposite* l1tr = l1TriggerResult->at(0);
    std::string ctpKey;
    if (l1tr->getDetail<std::string>("CTPResultKey", ctpKey)) {
      ATH_MSG_WARNING("L1TriggerResult contains CTPResult ReadHandleKey but CTP bytestream encoding tool is not enabled");
    }
  }
 
  //  ===== MuonRoI + eFex encoding =================
 
  for (ToolHandle<IL1TriggerByteStreamTool>& tool : {std::reference_wrapper(m_muonEncoderTool), std::reference_wrapper(m_muonEncoderToolDaq), std::reference_wrapper(m_efexEncoderTool), std::reference_wrapper(m_jfexEncoderTool), std::reference_wrapper(m_gfexEncoderTool), std::reference_wrapper(m_ctpResultEncoderTool)}) {
    if (not tool.isEnabled()) {continue;}
    std::vector<WROBF*> muon_robs;
    ATH_CHECK(tool->convertToBS(muon_robs, l1TriggerResult, ctx)); // TODO: find a way to avoid ThreadLocalContext
    ATH_MSG_DEBUG(tool.name() << " created " << muon_robs.size() << " L1Muon ROB Fragments");
    for (WROBF* rob : muon_robs) {
      printRob(*rob);
      // Set LVL1 Trigger Type from the full event
      rob->rod_lvl1_type(re->lvl1_trigger_type());
      // Set LVL1 ID from the full event
      rob->rod_lvl1_id(re->lvl1_id());
      // Add the ROBFragment to the full event
      re->append(rob);
      ATH_MSG_DEBUG("Added ROB fragment 0x" << MSG::hex << rob->source_id() << MSG::dec << " to the output raw event");
    }
  }
 
  // Placeholder for other systems: L1Topo, gFEX
 
  // Create a ByteStreamAddress for L1TriggerResult
  if ( pAddr != nullptr ) pAddr->release();
  ByteStreamAddress* bsAddr = new ByteStreamAddress(classID(), pObj->registry()->name(), "");
  pAddr = static_cast<IOpaqueAddress*>(bsAddr);
  pAddr->addRef();
 
  ATH_MSG_VERBOSE("end of " << __FUNCTION__);
  return StatusCode::SUCCESS;
}
 
// =============================================================================
// Debug print helper
// =============================================================================
void L1TriggerResultByteStreamCnv::printRob(const OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment& rob) const {
  if (not msgLvl(MSG::DEBUG)) {return;}
  const uint32_t ndata = rob.rod_ndata();
  const uint32_t* data = rob.rod_data();
  ATH_MSG_DEBUG("This ROB has " << ndata << " data words");
  for (uint32_t i=0; i<ndata; ++i, ++data) {
    ATH_MSG_DEBUG("--- 0x" << MSG::hex << *data << MSG::dec);
  }
}
 
// =============================================================================
// CLID / storageType
// =============================================================================
CLID L1TriggerResultByteStreamCnv::classID() {
  return ClassID_traits<xAOD::TrigCompositeContainer>::ID();
}
 
long L1TriggerResultByteStreamCnv::storageType() {
  return ByteStreamAddress::storageType();
}