RoIBResultByteStreamTool Class Reference

Tool doing the RoIBResult <-> ByteStream conversion. More...

#include <RoIBResultByteStreamTool.h>

Inheritance diagram for RoIBResultByteStreamTool:

Collaboration diagram for RoIBResultByteStreamTool:

Classes
struct	DataStatus
	Structure holding the status words and rob/rod error flags. More...

Public Member Functions
	RoIBResultByteStreamTool (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor. More...
virtual	~RoIBResultByteStreamTool ()=default
	Default destructor. More...
virtual StatusCode	initialize () override
	Function to initialise the tool. More...
virtual StatusCode	convertFromBS (const std::vector< const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment * > &vrobf, const EventContext &eventContext) const override
	Convert ROB fragments to RoIBResult. More...
virtual StatusCode	convertToBS (std::vector< OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * > &vrobf, const EventContext &eventContext) override
	Convert RoIBResult to ByteStream. More...
virtual const std::vector< uint32_t > &	robIds () const override
	Vector of ROB IDs corresponding to the modules configured for decoding. More...
template<typename RoIType >
std::vector< RoIType >	roibContent (const ROBFragment &rob) const

Private Member Functions
ROIB::Header	roibHeader (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &rob, DataStatus &dataStatus) const
	Helper method to extract ROD header information @in rob ROBFragment from which data are extracted @out dataStatus Structure to flag data errors. More...
template<typename RoIType >
std::vector< RoIType >	roibContent (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &rob) const
	Helper method to extract ROD payload @in ndata Number of data words @in data Data words. More...
L1TopoRDO	l1topoContent (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &rob) const
	Helper method to extract ROD payload for L1Topo (different interface from other RoI data) @in ndata Number of data words @in data Data words. More...
ROIB::Trailer	roibTrailer (const DataStatus &dataStatus, const uint32_t dataSize) const
	Helper method to extract ROD trailer information @in dataStatus Structure to flag data errors (extracted from the header) @in dataSize Number of ROD data words. More...

Private Attributes
Gaudi::Property< uint16_t >	m_detEvType
	Detector event type to write when converting to ByteStream. More...
std::vector< uint32_t >	m_configuredROBIds
	Vector of ROB IDs corresponding to the modules configured for decoding. More...
SmartIF< IByteStreamEventAccess >	m_byteStreamEventAccess
	Interface to get raw event pointer for updating event header when writing to BS. More...
Properties holding module IDs for L1 RoI ROBs
CTP Module ID to decode
Gaudi::Property< uint16_t >	m_ctpModuleID
Gaudi::Property< uint16_t >	m_muCTPIModuleID
	MUCTPI Module ID to decode. More...
Gaudi::Property< std::vector< uint16_t > >	m_jetModuleID
	Jet Module IDs to decode. More...
Gaudi::Property< std::vector< uint16_t > >	m_emModuleID
	EM Module IDs to decode. More...
Gaudi::Property< std::vector< uint16_t > >	m_l1TopoModuleID
	L1Topo Module IDs to decode. More...
Data handles
SG::WriteHandleKey< ROIB::RoIBResult >	m_roibResultWriteKey
SG::ReadHandleKey< ROIB::RoIBResult >	m_roibResultReadKey
Flags to switch decoding/encoding of each system
bool	m_doCTP {true}
bool	m_doMuon {true}
bool	m_doJetEnergy {true}
bool	m_doEMTau {true}
bool	m_doTopo {true}

Detailed Description

Tool doing the RoIBResult <-> ByteStream conversion.

   The actual work of translating the information in an RoIBResult object
   into ROB fragments and vice-versa is done with this tool.

See also

RoIBResultByteStreamCnv

Author

Tadashi Maeno

Attila Krasznahorkay

Definition at line 39 of file RoIBResultByteStreamTool.h.

Constructor & Destructor Documentation

RoIBResultByteStreamTool()

RoIBResultByteStreamTool::RoIBResultByteStreamTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Default constructor.

The constructor takes care of correctly constructing the base class and declaring the tool's interface to the framework.

Definition at line 32 of file RoIBResultByteStreamTool.cxx.

  : base_class(type, name, parent) {}

~RoIBResultByteStreamTool()

virtual RoIBResultByteStreamTool::~RoIBResultByteStreamTool ( )

virtualdefault

Default destructor.

Member Function Documentation

convertFromBS()

StatusCode RoIBResultByteStreamTool::convertFromBS ( const std::vector< const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment * > &  vrobf, const EventContext &  eventContext  ) const

overridevirtual

Convert ROB fragments to RoIBResult.

Definition at line 241 of file RoIBResultByteStreamTool.cxx.

                                                                                           {
 
  if (m_roibResultWriteKey.empty()) {
    ATH_MSG_ERROR("Conversion from BS to xAOD RoI requested but RoI WriteHandleKey is empty");
    return StatusCode::FAILURE;
  }
  // Create all RDOs
  ROIB::CTPResult cTPResult;
  ROIB::MuCTPIResult muCTPIResult;
  std::vector< ROIB::JetEnergyResult > jetEnergyResult(2);
  std::vector< ROIB::EMTauResult > eMTauResult(4);
  std::vector< ROIB::L1TopoResult > l1TopoResult;
 
  // Create flags indicating whether or not ROB fragment was found
  bool cTPFound = false;
  bool muCTPIFound = false;
  bool jetEnergyFound[2] = {false, false};
  bool eMTauFound[4] = {false, false, false, false};
  bool l1TopoFound = false;
 
  // Loop over ROB fragments
  for (const ROBFragment* p_robf : vrobf) {
    const ROBFragment& robf = *p_robf;
    eformat::helper::SourceIdentifier rodSID(robf.rod_source_id());
    eformat::SubDetector rodSubdetId = rodSID.subdetector_id();
    uint16_t rodModuleId = rodSID.module_id();
 
    switch (rodSubdetId) {
      // -----------------------------------------------------------------------
      // CTP
      // -----------------------------------------------------------------------
      case eformat::TDAQ_CTP: {
        if (!m_doCTP) continue;
 
        // Check if the current ROD module ID matches the configured CTP module ID.
        // Accept also ctpModuleId=0 to catch the early data with the old CTP firmware, which assigns 0x770000 to both
        // DAQ and LVL2 ROD fragment - for this data we readout always multiple bunches for the DAQ ROD, therefore
        // rodFragSize=46 should identify the LVL2 ROD fragment
        if (rodModuleId != m_ctpModuleID && rodModuleId != 0) continue;
        if (rodModuleId == 0 && robf.rod_fragment_size_word() != 46) continue;
 
        // Flag as found
        cTPFound = true;
        ATH_MSG_DEBUG("   Found CTP ROD with source ID " << MSG::hex << rodSID.code() << MSG::dec);
 
        // Extract the data
        DataStatus status;
        ROIB::Header header = roibHeader(robf, status);
        std::vector<ROIB::CTPRoI> content = roibContent<ROIB::CTPRoI>(robf);
        ROIB::Trailer trailer = roibTrailer(status, content.size());
 
        // Extract the CTP version number
        const uint32_t* rod;
        robf.rod_start(rod);
        unsigned int ctpVersionNumber = ((rod[CTPdataformat::Helper::FormatVersionPos] >> CTPdataformat::CTPFormatVersionShift) & CTPdataformat::CTPFormatVersionMask);
 
        // Create CTPResult object
        cTPResult = ROIB::CTPResult(ctpVersionNumber, std::move(header), std::move(trailer), std::move(content));
        break;
      }
 
      // -----------------------------------------------------------------------
      // MUCTPI
      // -----------------------------------------------------------------------
      case eformat::TDAQ_MUON_CTP_INTERFACE: {
        if (!m_doMuon) continue;
 
        // Check if the current ROD module ID matches the configured MuCTPI module ID
        if (rodModuleId != m_muCTPIModuleID) continue;
 
        // Flag as found
        muCTPIFound = true;
        ATH_MSG_DEBUG("   Found MuCTPI ROD with source ID " << MSG::hex << rodSID.code() << MSG::dec);
 
        // Extract the data
        DataStatus status;
        ROIB::Header header = roibHeader(robf, status);
        std::vector<ROIB::MuCTPIRoI> content = roibContent<ROIB::MuCTPIRoI>(robf);
        ROIB::Trailer trailer = roibTrailer(status, content.size());
 
        // Create MuCTPIResult object
        muCTPIResult = ROIB::MuCTPIResult(std::move(header), std::move(trailer), std::move(content));
        break;
      }
 
      // -----------------------------------------------------------------------
      // Jet/Energy
      // -----------------------------------------------------------------------
      case eformat::TDAQ_CALO_JET_PROC_ROI: {
        if (!m_doJetEnergy) continue;
 
        // Check if the current ROD module ID matches the configured Jet/Energy module IDs
        auto it = std::find(m_jetModuleID.begin(), m_jetModuleID.end(), rodModuleId);
        if (it == m_jetModuleID.end()) continue;
        size_t index = static_cast<size_t>(std::distance(m_jetModuleID.begin(), it));
 
        // Flag as found
        jetEnergyFound[index] = true;
        ATH_MSG_DEBUG("   Found Jet/Energy ROD with source ID " << MSG::hex << rodSID.code() << MSG::dec);
 
        // Extract the data
        DataStatus status;
        ROIB::Header header = roibHeader(robf, status);
        std::vector<ROIB::JetEnergyRoI> content = roibContent<ROIB::JetEnergyRoI>(robf);
        ROIB::Trailer trailer = roibTrailer(status, content.size());
 
        // Create JetEnergyResult object
        jetEnergyResult[index] = ROIB::JetEnergyResult(std::move(header), std::move(trailer), std::move(content));
        break;
      }
 
      // -----------------------------------------------------------------------
      // EM/Tau
      // -----------------------------------------------------------------------
      case eformat::TDAQ_CALO_CLUSTER_PROC_ROI: {
        if (!m_doEMTau) continue;
 
        // Check if the current ROD module ID matches the configured EM/Tau module IDs
        auto it = std::find(m_emModuleID.begin(), m_emModuleID.end(), rodModuleId);
        if (it == m_emModuleID.end()) continue;
        size_t index = static_cast<size_t>(std::distance(m_emModuleID.begin(), it));
 
        // Flag as found
        eMTauFound[index] = true;
        ATH_MSG_DEBUG("   Found EM/Tau ROD with source ID " << MSG::hex << rodSID.code() << MSG::dec);
 
        // Extract the data
        DataStatus status;
        ROIB::Header header = roibHeader(robf, status);
        std::vector<ROIB::EMTauRoI> content = roibContent<ROIB::EMTauRoI>(robf);
        ROIB::Trailer trailer = roibTrailer(status, content.size());
 
        // Create EMTauResult object
        eMTauResult[index] = ROIB::EMTauResult(std::move(header), std::move(trailer), std::move(content));
        break;
      }
 
      // -----------------------------------------------------------------------
      // L1Topo
      // -----------------------------------------------------------------------
      case eformat::TDAQ_CALO_TOPO_PROC: {
        if (!m_doTopo) continue;
 
        // Check if the current ROD module ID matches the configured L1Topo module IDs
        auto it = std::find(m_l1TopoModuleID.begin(), m_l1TopoModuleID.end(), rodModuleId);
        if (it == m_l1TopoModuleID.end()) continue;
 
        // Flag as found
        l1TopoFound = true;
        ATH_MSG_DEBUG("   Found L1Topo ROD with source ID " << MSG::hex << rodSID.code() << MSG::dec);
 
        // Extract the data
        DataStatus status;
        ROIB::Header header = roibHeader(robf, status);
        L1TopoRDO content = l1topoContent(robf);
        ROIB::Trailer trailer = roibTrailer(status, content.getDataWords().size());
 
        // Set status words
        content.setStatusWords({status.status_word, status.status_info});
 
        // Flag errors in RDO
        if (status.status_word != 0) content.setError(L1Topo::Error::SLINK_STATUS_ERROR);
        if (status.rob_error) content.setError(L1Topo::Error::ROB_ERROR);
        if (status.rod_error) content.setError(L1Topo::Error::ROD_ERROR);
 
        // Create L1TopoResult object
        l1TopoResult.emplace_back(std::move(header), std::move(trailer), std::move(content));
        break;
      }
 
      default: {
        ATH_MSG_DEBUG("Skipping ROD with SubDetID " << rodSID.human_detector());
        break;
      }
    }
 
  } // End of loop over all ROB fragments
 
  ATH_MSG_DEBUG("Building RoIBResult with the following inputs:");
  ATH_MSG_DEBUG("  CTP             - " << (cTPFound ? "found" : "not found"));
  ATH_MSG_DEBUG("  MUCTPI          - " << (muCTPIFound ? "found" : "not found"));
  ATH_MSG_DEBUG("  Jet/Energy[0/1] - " << (jetEnergyFound[0] ? "found" : "not found") << "/"
                                       << (jetEnergyFound[1] ? "found" : "not found"));
  ATH_MSG_DEBUG("  EM/Tau[0/1/2/3] - " << (eMTauFound[0] ? "found" : "not found") << "/"
                                       << (eMTauFound[1] ? "found" : "not found") << "/"
                                       << (eMTauFound[2] ? "found" : "not found") << "/"
                                       << (eMTauFound[3] ? "found" : "not found"));
  ATH_MSG_DEBUG("  L1Topo          - " << (l1TopoFound ? "found" : "not found"));
 
 
  // Create and record the RoIBResult
  auto roibResult = SG::makeHandle(m_roibResultWriteKey, eventContext);
  ATH_CHECK(roibResult.record(std::make_unique<ROIB::RoIBResult>(std::move(muCTPIResult), std::move(cTPResult), std::move(jetEnergyResult), std::move(eMTauResult))));
  ATH_MSG_DEBUG("Recorded RoIBResult with key " << m_roibResultWriteKey.key());
 
  // Add L1Topo result
  if (l1TopoFound) roibResult->l1TopoResult(std::move(l1TopoResult));
 
  return StatusCode::SUCCESS;
}

convertToBS()

StatusCode RoIBResultByteStreamTool::convertToBS ( std::vector< OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment * > &  vrobf, const EventContext &  eventContext  )

overridevirtual

Convert RoIBResult to ByteStream.

Definition at line 129 of file RoIBResultByteStreamTool.cxx.

                                                                                   {
  auto roibResult = SG::makeHandle(m_roibResultReadKey, eventContext);
  ATH_CHECK(roibResult.isValid());
  ATH_MSG_DEBUG("Obtained ROIB::RoIBResult with key " << m_roibResultReadKey.key() << " for conversion to ByteStream");
 
  auto addRob = [&](const eformat::helper::SourceIdentifier& sid, const size_t ndata, const uint32_t* data){
    vrobf.push_back(newRobFragment(eventContext, sid.code(), ndata, data, m_detEvType));
    return vrobf.back();
  };
  auto convertDataToRob = [&](const eformat::helper::SourceIdentifier& sid, const auto& dataVec){
    uint32_t* data = newRodData(eventContext, dataVec.size());
    ATH_MSG_VERBOSE("Dumping words for " << sid.human());
    for (size_t i=0; i<dataVec.size(); ++i) {
      ATH_MSG_VERBOSE("  0x" << MSG::hex << std::setw(8) << dataVec.at(i).roIWord() << MSG::dec);
      data[i] = dataVec.at(i).roIWord();
    }
    return addRob(sid, dataVec.size(), data);
  };
 
  // CTP
  if (m_doCTP) {
    const eformat::helper::SourceIdentifier ctpSID{eformat::TDAQ_CTP, m_ctpModuleID};
    const std::vector<ROIB::CTPRoI>& ctpDataVec = roibResult->cTPResult().roIVec();
    OFFLINE_FRAGMENTS_NAMESPACE_WRITE::ROBFragment* rob = convertDataToRob(ctpSID, ctpDataVec);
 
    // Update ROD minor version which encodes extra information about CTP data format (e.g. number of extra words)
    rob->rod_minor_version(roibResult->cTPResult().header().formatVersion() & 0xffffu);
 
    // Update L1 bits in event header
    // TODO: change to context-aware method when it is added to the IByteStreamEventAccess interface
    RawEventWrite* rawEvent = m_byteStreamEventAccess->getRawEvent();
    std::bitset<512> tbp = ROIB::convertToBitset(roibResult->cTPResult().TBP());
    std::bitset<512> tap = ROIB::convertToBitset(roibResult->cTPResult().TAP());
    std::bitset<512> tav = ROIB::convertToBitset(roibResult->cTPResult().TAV());
    constexpr size_t word_size = 32; // ATLAS raw event format word size
    constexpr size_t words_per_set = 512 / word_size; // 512 CTP bits / word size
    constexpr size_t num_words = 3 * words_per_set; // 3 sets: TBP, TAP, TAV
    uint32_t* l1bits_data = newRodData(eventContext, num_words);
    size_t iset{0};
    for (const std::bitset<512>& bset : {tbp, tap, tav}) {
      const std::string sbits = bset.to_string();
      const size_t iword_output_start = words_per_set * iset;
      for (size_t iword_in_set = 0; iword_in_set < words_per_set; ++iword_in_set) {
        const size_t bword_pos = 512 - (iword_in_set+1) * word_size;
        std::bitset<word_size> bword{sbits.substr(bword_pos, word_size)};
        l1bits_data[iword_output_start + iword_in_set] = static_cast<uint32_t>(bword.to_ulong());
      }
      ++iset;
    }
    rawEvent->lvl1_trigger_info(num_words, l1bits_data);
 
    // Update L1 TriggerType in event header
    const uint32_t triggerType = roibResult->cTPResult().header().triggerType();
    rawEvent->lvl1_trigger_type(static_cast<uint8_t>(triggerType & 0xFF));
  }
 
  // Muon
  if (m_doMuon) {
    const eformat::helper::SourceIdentifier muctpiSID{eformat::TDAQ_MUON_CTP_INTERFACE, m_muCTPIModuleID};
    const std::vector<ROIB::MuCTPIRoI>& muctpiDataVec = roibResult->muCTPIResult().roIVec();
    convertDataToRob(muctpiSID, muctpiDataVec);
  }
 
  // Jet/Energy
  if (m_doJetEnergy) {
    const std::vector<ROIB::JetEnergyResult>& jetEnergyResultVec = roibResult->jetEnergyResult();
    for (size_t slink=0; slink<jetEnergyResultVec.size(); ++slink) {
      const eformat::helper::SourceIdentifier jetSID{eformat::TDAQ_CALO_JET_PROC_ROI, m_jetModuleID.value().at(slink)};
      convertDataToRob(jetSID, jetEnergyResultVec.at(slink).roIVec());
    }
  }
 
  // EMTau
  if (m_doEMTau) {
    const std::vector<ROIB::EMTauResult>& emTauResultVec = roibResult->eMTauResult();
    for (size_t slink=0; slink<emTauResultVec.size(); ++slink) {
      const eformat::helper::SourceIdentifier emSID{eformat::TDAQ_CALO_CLUSTER_PROC_ROI, m_emModuleID.value().at(slink)};
      convertDataToRob(emSID, emTauResultVec.at(slink).roIVec());
    }
  }
 
  // L1Topo (slightly different interface from the others)
  if (m_doTopo) {
    const std::vector<ROIB::L1TopoResult>& l1TopoResultVec = roibResult->l1TopoResult();
    for (size_t slink=0; slink<l1TopoResultVec.size(); ++slink) {
      eformat::helper::SourceIdentifier topoSID{l1TopoResultVec.at(slink).rdo().getSourceID()};
      ATH_MSG_VERBOSE("L1Topo source ID from RDO "  << L1Topo::formatHex8(topoSID.code()));
      if (topoSID.code() == 0 && slink < m_l1TopoModuleID.size()) {
        topoSID = eformat::helper::SourceIdentifier(eformat::TDAQ_CALO_TOPO_PROC, m_l1TopoModuleID.value().at(slink));
        ATH_MSG_DEBUG("Source ID in L1TopoRDO was zero so using Property for slink " << slink << ": "
                      << L1Topo::formatHex8(topoSID.code()));
      }
      else if (topoSID.code() == 0) {
        topoSID = eformat::helper::SourceIdentifier( eformat::TDAQ_CALO_TOPO_PROC, 0 );
        ATH_MSG_WARNING("Source ID in L1TopoRDO was zero, no properties available for slink counter " << slink
                        << ", so as a fall back, constructed module 0 with source ID "
                        << L1Topo::formatHex8(topoSID.code()));
      }
      const std::vector<uint32_t>& dataVec = l1TopoResultVec.at(slink).rdo().getDataWords();
      uint32_t* data = newRodData(eventContext, dataVec.size());
      for (size_t i=0; i<dataVec.size(); ++i) {
        ATH_MSG_VERBOSE("  " << MSG::hex << std::setw(8) << std::showbase << dataVec.at(i) << std::noshowbase << MSG::dec);
        data[i] = dataVec.at(i);
      }
      addRob(topoSID, dataVec.size(), data);
    }
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode RoIBResultByteStreamTool::initialize ( )

overridevirtual

Function to initialise the tool.

Initialise the tool.

Fill the vector of configured ROB IDs and print the module IDs to debug message stream

Definition at line 41 of file RoIBResultByteStreamTool.cxx.

                                                {
  ATH_MSG_DEBUG("Initialising RoIBResultByteStreamTool");
 
  ConversionMode mode = getConversionMode(m_roibResultReadKey, m_roibResultWriteKey, msg());
  ATH_CHECK(mode!=ConversionMode::Undefined);
 
  // Set flags enabling/disabling each system
  m_doCTP = (m_ctpModuleID != 0xFF);
  m_doMuon = (m_muCTPIModuleID != 0xFF);
  m_doJetEnergy = !m_jetModuleID.empty();
  m_doEMTau = !m_emModuleID.empty();
  m_doTopo = !m_l1TopoModuleID.empty();
 
  if (msgLvl(MSG::DEBUG)) {
    std::string_view modeName {(mode==ConversionMode::Encoding) ? "encoding" : "decoding"};
    auto enabledStr = [](bool v) constexpr {return std::string_view(v ? "enabled" : "disabled");};
    ATH_MSG_DEBUG("CTP " << modeName << " is " << enabledStr(m_doCTP));
    ATH_MSG_DEBUG("MUCTPI " << modeName << " is " << enabledStr(m_doMuon));
    ATH_MSG_DEBUG("Jet/Energy " << modeName << " is " << enabledStr(m_doJetEnergy));
    ATH_MSG_DEBUG("EMTau " << modeName << " is " << enabledStr(m_doEMTau));
    ATH_MSG_DEBUG("L1Topo " << modeName << " is " << enabledStr(m_doTopo));
  }
 
  // Initialise data handles
  ATH_CHECK(m_roibResultWriteKey.initialize(mode==ConversionMode::Decoding));
  ATH_CHECK(m_roibResultReadKey.initialize(mode==ConversionMode::Encoding));
 
  // Set configured ROB IDs from module IDs
  std::vector<eformat::helper::SourceIdentifier> configuredROBSIDs;
  std::ostringstream str;
  ATH_MSG_DEBUG("Configured module IDs for:");
 
  // CTP
  if (m_doCTP) {
    configuredROBSIDs.emplace_back(eformat::TDAQ_CTP, m_ctpModuleID);
    ATH_MSG_DEBUG("   CTP                                  = 0x" << MSG::hex << m_ctpModuleID.value() << MSG::dec);
  }
 
  // MUCTPI
  if (m_doMuon) {
    configuredROBSIDs.emplace_back(eformat::TDAQ_MUON_CTP_INTERFACE, m_muCTPIModuleID);
    ATH_MSG_DEBUG("   muCTPi                               = 0x" << MSG::hex << m_muCTPIModuleID.value() << MSG::dec);
  }
 
  // Jet/Energy
  if (m_doJetEnergy) {
    str.str("");
    for (const uint16_t module_id : m_jetModuleID) {
      configuredROBSIDs.emplace_back(eformat::TDAQ_CALO_JET_PROC_ROI, module_id);
      str << "0x" << std::hex << module_id << std::dec << " ";
    }
    ATH_MSG_DEBUG("   Calorimeter Jet/Energy Processor RoI = " << str.str());
  }
 
  // EM/Tau
  if (m_doEMTau) {
    str.str("");
    for (const uint16_t module_id : m_emModuleID) {
      configuredROBSIDs.emplace_back(eformat::TDAQ_CALO_CLUSTER_PROC_ROI, module_id);
      str << "0x" << std::hex << module_id << std::dec << " ";
    }
    ATH_MSG_DEBUG("   Calorimeter Cluster Processor RoI    = " << str.str());
  }
 
  // L1Topo
  if (m_doTopo) {
    str.str("");
    for (const uint16_t module_id : m_l1TopoModuleID) {
      configuredROBSIDs.emplace_back(eformat::TDAQ_CALO_TOPO_PROC, module_id);
      str << "0x" << std::hex << module_id << std::dec << " ";
    }
    ATH_MSG_DEBUG("   L1Topo                               = " << str.str());
  }
 
  // Fill the ROB ID vector
  for (const auto& sid : configuredROBSIDs) {
    m_configuredROBIds.push_back( sid.code() );
  }
 
  // Retrieve the ByteStreamCnvSvc for updating event header when writing CTP data to BS
  if (m_doCTP && mode==ConversionMode::Encoding) {
    m_byteStreamEventAccess = serviceLocator()->service("ByteStreamCnvSvc");
    ATH_CHECK(m_byteStreamEventAccess.isValid());
  }
 
  return StatusCode::SUCCESS;
}

l1topoContent()

L1TopoRDO RoIBResultByteStreamTool::l1topoContent ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &  rob ) const

private

Helper method to extract ROD payload for L1Topo (different interface from other RoI data) @in ndata Number of data words @in data Data words.

Definition at line 524 of file RoIBResultByteStreamTool.cxx.

                                                                              {
  uint32_t ndata = rob.rod_ndata();
  DataType data;
  rob.rod_data(data);
  L1TopoRDO content;
  ATH_MSG_VERBOSE( "   Dumping RoI Words:" );
  std::vector<uint32_t> vDataWords;
  vDataWords.reserve(ndata);
  for (const uint32_t word : std::span{data, ndata}) {
    ATH_MSG_VERBOSE("       0x" << MSG::hex << std::setfill('0') << std::setw(8) << word << MSG::dec);
    vDataWords.push_back(word);
  }
  content.setDataWords(std::move(vDataWords));
  content.setSourceID(rob.rod_source_id());
  return content;
}

robIds()

virtual const std::vector<uint32_t>& RoIBResultByteStreamTool::robIds ( ) const

inlineoverridevirtual

Vector of ROB IDs corresponding to the modules configured for decoding.

Definition at line 60 of file RoIBResultByteStreamTool.h.

{return m_configuredROBIds;}

roibContent() [1/2]

template<typename RoIType >

std::vector<RoIType> RoIBResultByteStreamTool::roibContent ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &  rob ) const

private

Helper method to extract ROD payload @in ndata Number of data words @in data Data words.

roibContent() [2/2]

template<typename RoIType >

std::vector<RoIType> RoIBResultByteStreamTool::roibContent

(

const ROBFragment &

rob

)

const

Definition at line 510 of file RoIBResultByteStreamTool.cxx.

                                                                                                                {
  uint32_t ndata = rob.rod_ndata();
  DataType data;
  rob.rod_data(data);
  std::vector<RoIType> content;
  content.reserve(ndata);
  ATH_MSG_VERBOSE("   Dumping RoI Words:");
  for (const uint32_t word : std::span{data, ndata}) {
    ATH_MSG_VERBOSE("       0x" << MSG::hex << std::setfill('0') << std::setw(8) << word << MSG::dec);
    content.push_back(RoIType{word});
  }
  return content;
}

roibHeader()

ROIB::Header RoIBResultByteStreamTool::roibHeader ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &  rob, DataStatus &  dataStatus  ) const

private

Helper method to extract ROD header information @in rob ROBFragment from which data are extracted @out dataStatus Structure to flag data errors.

Definition at line 443 of file RoIBResultByteStreamTool.cxx.

                                                                                {
  // Get format version and event number of fragment
  uint32_t formatVersion = rob.rod_version();
  uint32_t evtNum = rob.rod_lvl1_id();
  uint32_t robFragSize = rob.fragment_size_word();
  uint32_t rodFragSize = rob.rod_fragment_size_word();
  uint32_t robId = rob.source_id();
  uint32_t rodId = rob.rod_source_id();
 
  // Check for errors
  dataStatus.rob_error = false;
  dataStatus.rod_error = false;
  dataStatus.status_word = 0;
  dataStatus.status_info = 0;
 
  try {
    if (rob.check_rob()) ATH_MSG_VERBOSE("ROB fragment checked ok");
  }
  catch (std::exception const & ex) {
    ATH_MSG_WARNING("ROB fragment not valid: " << ex.what());
    dataStatus.rob_error = true;
  }
 
  try {
    if (rob.check_rod()) ATH_MSG_VERBOSE("ROD fragment checked ok");
  }
  catch (std::exception const & ex) {
    ATH_MSG_WARNING("ROD fragment not valid: " << ex.what());
    dataStatus.rod_error = true;
  }
 
  // Process the status words
  DataType status;
  rob.rod_status(status);
  uint32_t nstatus = rob.rod_nstatus();
  ATH_MSG_VERBOSE("Number of status words: " << nstatus);
  if (msgLvl(MSG::VERBOSE)) {
    for (uint32_t i=0; i<nstatus; ++i, ++status) {
      ATH_MSG_VERBOSE("   Status word: 0x" << MSG::hex << std::setw(8) << std::setfill('0') << *status);
    }
  }
  rob.rod_status(status);
 
  if(nstatus > 0) dataStatus.status_word = static_cast<uint32_t>(*status);
  if(nstatus > 1) {
      ++status;
      dataStatus.status_info = static_cast<uint32_t>(*status);
  }
 
  ATH_MSG_DEBUG("ROB ID 0x" << MSG::hex << robId <<  " ROD ID 0x" << rodId << MSG::dec << " ROB fragment size "
                << robFragSize << " ROD fragment size " << rodFragSize);
 
  return ROIB::Header(rodId, evtNum, formatVersion);
}

roibTrailer()

ROIB::Trailer RoIBResultByteStreamTool::roibTrailer ( const DataStatus &  dataStatus, const uint32_t  dataSize  ) const

private

Helper method to extract ROD trailer information @in dataStatus Structure to flag data errors (extracted from the header) @in dataSize Number of ROD data words.

Definition at line 499 of file RoIBResultByteStreamTool.cxx.

                                                                                                       {
  std::vector<uint32_t> words;
  words.reserve(5);
  words.push_back(dataStatus.status_word); // error status
  words.push_back(dataStatus.status_info); // status info
  words.push_back(2);                      // number of status words
  words.push_back(dataSize);               // number of data words
  words.push_back(1);                      // status block position
  return ROIB::Trailer(std::move(words));
}

Member Data Documentation

m_byteStreamEventAccess

SmartIF<IByteStreamEventAccess> RoIBResultByteStreamTool::m_byteStreamEventAccess

private

Interface to get raw event pointer for updating event header when writing to BS.

Definition at line 154 of file RoIBResultByteStreamTool.h.

m_configuredROBIds

std::vector<uint32_t> RoIBResultByteStreamTool::m_configuredROBIds

private

Vector of ROB IDs corresponding to the modules configured for decoding.

Definition at line 152 of file RoIBResultByteStreamTool.h.

m_ctpModuleID

Gaudi::Property<uint16_t> RoIBResultByteStreamTool::m_ctpModuleID

private

Initial value:

{
    this, "CTPModuleId", 1,
    "Module ID of CTP ROB with RoI information. Value 0xFF disables CTP decoding/encoding in this tool."
  }

Definition at line 106 of file RoIBResultByteStreamTool.h.

m_detEvType

Gaudi::Property<uint16_t> RoIBResultByteStreamTool::m_detEvType

private

Initial value:

{
    this, "DetEvType", 1, 
    "Detector event type to write when converting to ByteStream"
  }

Detector event type to write when converting to ByteStream.

Definition at line 133 of file RoIBResultByteStreamTool.h.

m_doCTP

bool RoIBResultByteStreamTool::m_doCTP {true}

private

Definition at line 157 of file RoIBResultByteStreamTool.h.

m_doEMTau

bool RoIBResultByteStreamTool::m_doEMTau {true}

private

Definition at line 160 of file RoIBResultByteStreamTool.h.

m_doJetEnergy

bool RoIBResultByteStreamTool::m_doJetEnergy {true}

private

Definition at line 159 of file RoIBResultByteStreamTool.h.

m_doMuon

bool RoIBResultByteStreamTool::m_doMuon {true}

private

Definition at line 158 of file RoIBResultByteStreamTool.h.

m_doTopo

bool RoIBResultByteStreamTool::m_doTopo {true}

private

Definition at line 161 of file RoIBResultByteStreamTool.h.

m_emModuleID

Gaudi::Property<std::vector<uint16_t> > RoIBResultByteStreamTool::m_emModuleID

private

Initial value:

{
    this, "EMModuleIds", {0xa8, 0xa9, 0xaa, 0xab},
    "Vector of module IDs of EM RoI ROBs. Empty vector disables EMTau decoding/encoding in this tool."
  }

EM Module IDs to decode.

Definition at line 121 of file RoIBResultByteStreamTool.h.

m_jetModuleID

Gaudi::Property<std::vector<uint16_t> > RoIBResultByteStreamTool::m_jetModuleID

private

Initial value:

{
    this, "JetModuleIds", {0xac, 0xad},
    "Vector of module IDs of Jet RoI ROBs. Empty vector disables Jet/Energy decoding/encoding in this tool."
  }

Jet Module IDs to decode.

Definition at line 116 of file RoIBResultByteStreamTool.h.

m_l1TopoModuleID

Gaudi::Property<std::vector<uint16_t> > RoIBResultByteStreamTool::m_l1TopoModuleID

private

Initial value:

{
    this, "L1TopoModuleIds", {0x81,0x91},
    "Vector of module IDs of L1Topo RoI ROBs. Empty vector disables L1Topo decoding/encoding in this tool."
  }

L1Topo Module IDs to decode.

Definition at line 126 of file RoIBResultByteStreamTool.h.

m_muCTPIModuleID

Gaudi::Property<uint16_t> RoIBResultByteStreamTool::m_muCTPIModuleID

private

Initial value:

{
    this, "MUCTPIModuleId", 1,
    "Module ID of MUCTPI ROB with RoI information. Value 0xFF disables MUCTPI decoding/encoding in this tool."
  }

MUCTPI Module ID to decode.

Definition at line 111 of file RoIBResultByteStreamTool.h.

m_roibResultReadKey

SG::ReadHandleKey<ROIB::RoIBResult> RoIBResultByteStreamTool::m_roibResultReadKey

private

Initial value:

{
    this, "RoIBResultReadKey", "",
    "Read handle key to RoIBResult for conversion to ByteStream"
  }

Definition at line 144 of file RoIBResultByteStreamTool.h.

m_roibResultWriteKey

SG::WriteHandleKey<ROIB::RoIBResult> RoIBResultByteStreamTool::m_roibResultWriteKey

private

Initial value:

{
    this, "RoIBResultWriteKey", "",
    "Write handle key to RoIBResult for conversion from ByteStream"
  }

Definition at line 140 of file RoIBResultByteStreamTool.h.

---

The documentation for this class was generated from the following files:

• RoIBResultByteStreamTool.h
• RoIBResultByteStreamTool.cxx