AFP_ByteStream2RawCnv.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// AFP_ByteStream2RawCnv includes
#include "AFP_ByteStream2RawCnv/AFP_ByteStream2RawCnv.h"
 
#include "AFP_RawEv/AFP_SiRawData.h"
#include "AFP_RawEv/AFP_SiRawCollection.h"
 
#include "AFP_RawEv/AFP_ToFRawData.h"
#include "AFP_RawEv/AFP_ToFRawCollection.h"
 
#include <vector>
#include <algorithm> //std::find_if
#include <iterator> //std::prev
 
const InterfaceID &AFP_ByteStream2RawCnv::interfaceID() {
  static const InterfaceID IID_IAFP_ByteStream2RawCnv("AFP_ByteStream2RawCnv", 1, 0);
  return IID_IAFP_ByteStream2RawCnv;
}
 
AFP_ByteStream2RawCnv::AFP_ByteStream2RawCnv(const std::string &type,
                                             const std::string &name,
                                             const IInterface *parent)
  : AthAlgTool(type, name, parent),
    m_robDataProvider("ROBDataProviderSvc", name)
{
  declareInterface<AFP_ByteStream2RawCnv>(this);
}
 
AFP_ByteStream2RawCnv::~AFP_ByteStream2RawCnv() {}
 
StatusCode AFP_ByteStream2RawCnv::initialize() {
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  StatusCode sc = AthAlgTool::initialize();
  ATH_MSG_DEBUG("AFP_ByteStream2RawCnv::initialize");
  if (sc.isFailure()) {
    ATH_MSG_WARNING("Failed to initialize");
    return StatusCode::SUCCESS;
  }
 
  if (m_robDataProvider.retrieve().isFailure()) {
    ATH_MSG_WARNING("Failed to retrieve service " << m_robDataProvider
                    << "...");
    return StatusCode::SUCCESS;
  } else {
    ATH_MSG_DEBUG("Retrieved service " << m_robDataProvider << "...");
  }
 
   if (m_wordReadout.retrieve().isFailure()) {
    ATH_MSG_WARNING("Failed to retrieve service " << m_wordReadout
                    << "...");
    return StatusCode::SUCCESS;
  } else {
    ATH_MSG_DEBUG("Retrieved service " << m_wordReadout << "...");
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode AFP_ByteStream2RawCnv::finalize() {
  ATH_MSG_DEBUG("AFP_ByteStream2RawCnv: finalizing ");
 
  return StatusCode::SUCCESS;
}
 
StatusCode AFP_ByteStream2RawCnv::fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *robFrag, AFP_RawContainer *rawContainer) const {
  ATH_MSG_DEBUG("AFP_ByteStream2RawCnv::fillColelction rob_source_id: in decimal="<<std::dec<<robFrag->rob_source_id()<<",  in hex=0x"<<std::hex<<robFrag->rob_source_id()<<std::dec);
 
  try {
    robFrag->check();
  } catch (...) {
    ATH_MSG_WARNING("An exception occurred");
    return StatusCode::SUCCESS;
  }
 
  const uint32_t nStat = robFrag->nstatus();
  if (nStat) {
    const uint32_t *it;
    robFrag->status(it);
    if (*it) {
      ATH_MSG_WARNING(" Error in ROB status word: 0x");
      return StatusCode::SUCCESS;
    }
  }
 
  if (!rawContainer) {
    ATH_MSG_WARNING("NULL pointer passed in rawContainer argument.");
    return StatusCode::SUCCESS;
  }
 
  // --- end of check input parameters ---
 
  OFFLINE_FRAGMENTS_NAMESPACE::PointerType vint;
  robFrag->rod_data(vint);
 
  if (robFrag->rod_nstatus() <= 0) {
    ATH_MSG_WARNING("Buffer size <= 0!");
    return StatusCode::SUCCESS;
  }
 
  const eformat::FullEventFragment<const uint32_t*> *event = m_robDataProvider->getEvent(Gaudi::Hive::currentContext());
 
  // this information will be present only in offline reconstruction
  // not be at HLT; however the remaining AFP information will be
  // present both online and offline
  if (event) {
    // set information about event in the RawContainer
    rawContainer->setTimeStamp(event->bc_time_seconds());
    rawContainer->setTimeStampNS(event->bc_time_nanoseconds());
    rawContainer->setBCId(event->bc_id());
    rawContainer->setLumiBlock(event->lumi_block());
    rawContainer->setLvl1Id(event->lvl1_id());
  }
 
 
  // fill container with collections
  AFP_SiRawCollection *collectionSi = nullptr;
  AFP_ToFRawCollection *collectionToF = nullptr;
 
  std::array<uint32_t, 16> picoTDC_data = {};
 
  const uint32_t size = robFrag->rod_ndata();
  for (unsigned i = 0; i < size; i++) {
    uint32_t the_word=vint[i];
    uint32_t the_link=m_wordReadout->link(the_word);
 
    if (m_wordReadout->isHeader(the_word)) {
      AFP_RawCollectionHead* collectionHead = nullptr;
      if ( isLinkToF (the_link) ) {
        // prepare collection for time-of-flight
        collectionToF = getCollectionToF(//m_wordReadout->link(), robFrag->rob_source_id(), 
                                           rawContainer);
        collectionHead = collectionToF;
      }
      else if ( isLinkSi (the_link) ) {
        // prepare collection for silicon detector
        collectionSi = getCollectionSi(//m_wordReadout->link(), robFrag->rob_source_id(), 
                                         rawContainer);
        collectionHead = collectionSi;
      }
      else {
        ATH_MSG_ERROR("Unidentified value of link="<<the_link<<" for header record.");
        return StatusCode::FAILURE;
      }
 
      if (!collectionHead) {
        ATH_MSG_WARNING("nullptr returned by getCollection(link = "
                        << the_link << ", robID = " << robFrag->rob_source_id() <<")");
        return StatusCode::SUCCESS;
      }
 
      // set head collection informaiton
      collectionHead->setLvl1Id(m_wordReadout->getBits(the_word, 14, 10));
      collectionHead->setLink(the_link);
      collectionHead->setFrontendFlag(m_wordReadout->getBits(the_word, 15, 15));
      collectionHead->setBcId(m_wordReadout->getBits(the_word, 9, 0));
      collectionHead->setRobId(robFrag->rob_source_id());
    }
    else if (m_wordReadout->isData(the_word)) {
      // fill time-of-flight collection
      if ( isLinkToF (the_link) ) {
 
        // check if collection is available
        if ( !collectionToF ) {
          ATH_MSG_WARNING("No ToF collection available to fill data.");
          return StatusCode::SUCCESS;
        }
 
        uint32_t bit23=m_wordReadout->getBits(the_word, 23, 23);
        if(!bit23)
        {
          // HPTDC 2017
          uint32_t bits22_21=m_wordReadout->getBits(the_word, 22, 21);
          if(bits22_21==2)
          {
            // ToF measurement
            AFP_ToFRawData& ToFData = collectionToF->newDataRecord();
            ToFData.setHeader( m_wordReadout->getBits(the_word, 23, 21) );
            ToFData.setEdge( m_wordReadout->getBits(the_word, 20, 20) );
            ToFData.setChannel( m_wordReadout->getBits(the_word, 19, 16) );
            ToFData.setPulseLength( m_wordReadout->getBits(the_word, 15, 10) );
            ToFData.setTime( m_wordReadout->getBits(the_word, 9, 0) << 3 );
 
            setDataHeader (the_word, &ToFData);
          }
          else
          {
            ATH_MSG_DEBUG("This is not a ToF measurement, bit23 = "<<bit23<<", bits22_21 "<<bits22_21<<", ignoring word = "<<the_word);
          }
        }
        else
        {
          uint32_t bits23_22=m_wordReadout->getBits(the_word, 23, 22);
          if (bits23_22==0b10) {
            // picoTDC
 
            uint32_t bits21_20=m_wordReadout->getBits(the_word, 21, 20);
            if (bits21_20==0b10) {
              // ToF measurement
              uint32_t channel=m_wordReadout->getBits(the_word, 17, 14);
              uint32_t bit18=m_wordReadout->getBits(the_word, 18, 18);
              if (bit18==0) {
                // Fine 
                if (picoTDC_data[channel] == 0) {
                  picoTDC_data[channel] = the_word;
                } else {
                  if (m_wordReadout->getBits(picoTDC_data[channel], 18, 18) == 1) {
                    uint32_t fine_word = the_word;
                    uint32_t coarse_word = picoTDC_data[channel];
 
                    AFP_ToFRawData& ToFData = collectionToF->newDataRecord();
                    ToFData.setHeader( m_wordReadout->getBits(the_word, 23, 20) );
                    ToFData.setEdge( m_wordReadout->getBits(fine_word, 13, 13) );
                    ToFData.setChannel( channel );
                    ToFData.setPulseLength( m_wordReadout->getBits(coarse_word, 7, 0) );
                    ToFData.setTime( (m_wordReadout->getBits(coarse_word, 13, 8) << 13) | m_wordReadout->getBits(fine_word, 12, 0) );
 
                    setDataHeader (the_word, &ToFData);
 
                    picoTDC_data[channel] = 0;
                  } else {
                    ATH_MSG_WARNING("Fine time word for channel "<<channel<<" is already set to "<<picoTDC_data[channel]<<", cannot set it to "<<the_word<<", will not overwrite");
                  }
                }
              } else {
                // Coarse time + pulse length
                if (picoTDC_data[channel] == 0) {
                  picoTDC_data[channel] = the_word;
                } else {
                  if (m_wordReadout->getBits(picoTDC_data[channel], 18, 18) == 0) {
                    uint32_t fine_word = picoTDC_data[channel];
                    uint32_t coarse_word = the_word;
 
                    AFP_ToFRawData& ToFData = collectionToF->newDataRecord();
                    ToFData.setHeader( m_wordReadout->getBits(the_word, 23, 20) );
                    ToFData.setEdge( m_wordReadout->getBits(fine_word, 13, 13) );
                    ToFData.setChannel( channel );
                    ToFData.setPulseLength( m_wordReadout->getBits(coarse_word, 7, 0) );
                    ToFData.setTime( (m_wordReadout->getBits(coarse_word, 13, 8) << 13) | m_wordReadout->getBits(fine_word, 12, 0) );
 
                    setDataHeader (the_word, &ToFData);
 
                    picoTDC_data[channel] = 0;
                  } else {
                    ATH_MSG_WARNING("Coarse time word for channel "<<channel<<" is already set to "<<picoTDC_data[channel]<<", cannot set it to "<<the_word<<", will not overwrite");
                  }
                }
              }
            }
            else {
              ATH_MSG_DEBUG("This is not a ToF measurement, bits23_22 = "<<bits23_22<<", bits21_20 "<<bits21_20<<", ignoring word = "<<the_word);
            }
          }
          else {
            ATH_MSG_WARNING("Unexpected pattern in bits 22-23 = "<<bits23_22<<", ignoring word = "<<the_word);
          }
        }
      }
      else if ( isLinkSi (the_link) ) {
        // fill silicon detector collection
 
        // check if collection is available
        if ( !collectionSi ) {
          ATH_MSG_WARNING("No silicon detector collection available to fill data.");
          return StatusCode::SUCCESS;
        }
 
        // check first silicon hit information
        if (m_wordReadout->getBits(the_word, 7, 4) != s_siNoHitMarker) {
          AFP_SiRawData& siData = collectionSi->newDataRecord();
          siData.setColumn (m_wordReadout->getBits(the_word, 23, 17));
          siData.setRow (m_wordReadout->getBits(the_word, 16, 8));
          siData.setTimeOverThreshold (m_wordReadout->getBits(the_word, 7, 4));
          
          setDataHeader (the_word, &siData);
        }
 
        // check second silicon hit information
        if (m_wordReadout->getBits(the_word, 3, 0) != s_siNoHitMarker) {
          AFP_SiRawData& siData = collectionSi->newDataRecord();
          siData.setColumn (m_wordReadout->getBits(the_word, 23, 17));
          siData.setRow (m_wordReadout->getBits(the_word, 16, 8) + 1);
          siData.setTimeOverThreshold (m_wordReadout->getBits(the_word, 3, 0));
 
          setDataHeader (the_word, &siData);
        }
      }
      else {
        ATH_MSG_ERROR("Not recognised value of link="<<the_link<<" for data record.");
        return StatusCode::FAILURE;
      }
 
    } // end is data
  } // end of loop
  
  // in case of picoTDC, check we always have both words
  for (std::size_t channel=0;channel<picoTDC_data.size();++channel) {
    uint32_t word = picoTDC_data[channel];
    if (word != 0) {
      if (m_wordReadout->getBits(word, 18, 18) == 0) {
        ATH_MSG_WARNING("Incomplete picoTDC data for channel "<<channel<<", fine word "<<word<<" could not be paired");
      } else {
        ATH_MSG_WARNING("Incomplete picoTDC data for channel "<<channel<<", coarse word "<<word<<" could not be paired");
      }
    }
  }
  
  return StatusCode::SUCCESS;
}
 
AFP_SiRawCollection *
AFP_ByteStream2RawCnv::getCollectionSi(//const unsigned int link, const unsigned int robId,
                                       AFP_RawContainer *container) const {
 
  if (!container) {
    ATH_MSG_WARNING("NULL pointer passed in argument: container. NULL pointer returned.");
    return nullptr;
  }
 
  // Code below is commented, because it was impossible to
  // reconstruct several bunch crossings in one event with it. In
  // standard data taking only one bunch crossing is saved and this
  // protection should not be necessary. However in case of big
  // readout problems the code may be needed, that is why it stays
  // commented here.
 
  // for (const AFP_SiRawCollection& collection : container->collectionsSi())
  //   if (collection.link() == link && collection.robId() == robId)
  //     ATH_MSG_WARNING("Silicon collection link="<<link<<" robId="<<robId<<" already in container, although it should not be there. Anyway creating new collection. (Reading several BCX?)");
 
  AFP_SiRawCollection& newCollection = container->newCollectionSi();
  return &newCollection;
}
 
AFP_ToFRawCollection *
AFP_ByteStream2RawCnv::getCollectionToF(// const unsigned int link, const unsigned int robId,
                                        AFP_RawContainer *container) const {
 
  if (!container) {
    ATH_MSG_WARNING("NULL pointer passed in argument: container. NULL pointer returned.");
    return nullptr;
  }
  
  // Code below is commented, because it was impossible to
  // reconstruct several bunch crossings in one event with it. In
  // standard data taking only one bunch crossing is saved and this
  // protection should not be necessary. However in case of big
  // readout problems the code may be needed, that is why it stays
  // commented here.
 
  // for (const AFP_ToFRawCollection& collection : container->collectionsToF())
  //   if (collection.link() == link && collection.robId() == robId)
  //     ATH_MSG_WARNING("ToF collection link="<<link<<" robId="<<robId<<" already in container, although it should not be there. Anyway creating new collection (Reading several BCX?)");
 
  AFP_ToFRawCollection& newCollection = container->newCollectionToF();
  return &newCollection;
}
 
void AFP_ByteStream2RawCnv::setDataHeader (uint32_t the_word, AFP_RawDataCommonHead* dataHead) const
{
  dataHead->setLink (m_wordReadout->link(the_word));
  dataHead->setHitDiscConfig (m_wordReadout->getBits(the_word, 29, 28));
}