TGC_RodDecoderRawdata.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "TGC_RodDecoderRawdata.h"
 
#include "TgcByteStreamData.h"
#include "TgcRODReadOut.h"
#include "MuonRDO/TgcRdo.h"
#include "MuonRDO/TgcRdoContainer.h"
 
#include "Identifier/Identifier.h"
#include "eformat/Issue.h"
#include "eformat/SourceIdentifier.h"
 
using eformat::helper::SourceIdentifier;
using OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment;
 
//================ Constructor =================================================
 
Muon::TGC_RodDecoderRawdata::TGC_RodDecoderRawdata(const std::string& t,
                           const std::string& n,
                           const IInterface*  p) :
  base_class(t, n, p),
  m_tgcRODReadOut(nullptr)
{
  declareProperty("ReadSlbHeaderId", m_readSlbHeaderId=false);
  declareProperty("CheckRawData", m_checkRawData=false);
  declareProperty("ShowStatusWords", m_showStatusWords=false);
}
 
//================ Destructor =================================================
 
Muon::TGC_RodDecoderRawdata::~TGC_RodDecoderRawdata()
= default;
 
//================ Initialisation =================================================
 
StatusCode Muon::TGC_RodDecoderRawdata::initialize()
{
  ATH_CHECK( AthAlgTool::initialize() );
 
  ATH_CHECK( m_cablingSvc.retrieve() );
  m_tgcRODReadOut = new TgcRODReadOut(*(m_cablingSvc.get()));
  
  ATH_MSG_INFO( "initialize() successful in " << name() );
  return StatusCode::SUCCESS;
}
 
//================ Finalisation =================================================
 
StatusCode Muon::TGC_RodDecoderRawdata::finalize()
{
  delete m_tgcRODReadOut; m_tgcRODReadOut=nullptr;
  
  StatusCode sc = AthAlgTool::finalize();
  return sc;
}
 
//================ fillCollection ===============================================
 
StatusCode Muon::TGC_RodDecoderRawdata::fillCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const
{
  try   
    {
      robFrag.check();
    } catch (eformat::Issue &ex) {// error in fragment  
      ATH_MSG_WARNING(ex.what());
      return StatusCode::SUCCESS;
    }
 
  uint32_t source_id = robFrag.rod_source_id();
  SourceIdentifier sid(robFrag.rod_source_id());
    
  // do not convert if the TGC collection is already in the converter
  uint16_t rdoId = TgcRdo::calculateOnlineId(sid.subdetector_id(), sid.module_id());
  TgcRdoIdHash rdoIdHash;
  int idHash = rdoIdHash(rdoId);
        
  if(rdoIdc.indexFindPtr(idHash) == nullptr)
    {   
      OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs;
      robFrag.rod_data(bs);
      TgcRdo* rdo = getCollection(robFrag, rdoIdc);
 
      if(!rdo) {
    ATH_MSG_WARNING( "Pointer of RDO is NULL. Skip decoding of this ROD in this event..." );
    return StatusCode::SUCCESS;
      }
 
      if(m_checkRawData){
    byteStream2Rdo(bs, *rdo, robFrag.rod_source_id());
    if( !m_tgcRODReadOut->check(bs, *rdo, robFrag.rod_source_id())){
      ATH_MSG_WARNING( " Can't Check the contents of TgcRdo: Skip decoding of remaining hits of this event..." );
      return StatusCode::SUCCESS;
    }
      } else {  
    if( !m_tgcRODReadOut->byteStream2Rdo(bs, *rdo, robFrag.rod_source_id())){
      ATH_MSG_WARNING( " Can't Convert the TGC BS to Rdo: Skip decoding of remaining hits of this event..." );
      return StatusCode::SUCCESS;
    }
      }
    }
  else
    {
      ATH_MSG_DEBUG( " Collection ID = " << source_id 
             << "already found into the container; do not convert" );
    }
    
  return StatusCode::SUCCESS;
}
 
//================ getCollection ===============================================
 
TgcRdo* Muon::TGC_RodDecoderRawdata::getCollection(const ROBFragment& robFrag, TgcRdoContainer& rdoIdc) const
{
  TgcRdo* theColl = nullptr;
 
  uint32_t source_id = robFrag.rod_source_id();
  SourceIdentifier sid(source_id);
    
  uint16_t rdoId = TgcRdo::calculateOnlineId(sid.subdetector_id(), sid.module_id());
  TgcRdoIdHash rdoIdHash;
  int idHash = rdoIdHash(rdoId);
    
  ATH_MSG_DEBUG( " Created new Collection ID = " << sid.human() << " Hash = " << idHash );
 
  // create new collection
  theColl = new TgcRdo(rdoId, idHash);
  // add collection into IDC
  if(rdoIdc.addCollection(theColl, idHash).isFailure())
    {
      ATH_MSG_WARNING( "Failed to add TGC RDO collection to container" );
      delete theColl; theColl = nullptr;
      return nullptr;
    }
  theColl->setL1Id(robFrag.rod_lvl1_id());
  theColl->setBcId(robFrag.rod_bc_id());
  theColl->setTriggerType(robFrag.rod_lvl1_trigger_type());
  theColl->setOnlineId(sid.subdetector_id(), sid.module_id());
 
  uint32_t nstatus = robFrag.rod_nstatus();
  const uint32_t* status;
  robFrag.rod_status(status);
  theColl->setErrors(nstatus > 0 ? status[0] : 0);
  theColl->setRodStatus(nstatus > 1 ? status[1] : 0);
  theColl->setLocalStatus(nstatus > 3 ? status[3] : 0);
  theColl->setOrbit(nstatus > 4 ? status[4] : 0);
 
  if(m_showStatusWords) {
    showStatusWords(source_id, rdoId, idHash, nstatus, status);
  }
 
  return theColl;
}
 
//================ byteStream2Rdo ===============================================
 
void Muon::TGC_RodDecoderRawdata::byteStream2Rdo(OFFLINE_FRAGMENTS_NAMESPACE::PointerType bs,
                         TgcRdo& rdo,
                         uint32_t source_id) const
{
  ATH_MSG_DEBUG( "Muon::TGC_RodDecoder::byteStream2Rdo" );
    
  // Check that we are filling the right collection
  TGC_BYTESTREAM_SOURCEID sid;
  fromBS32(source_id, sid);
    
  if(rdo.identify() != TgcRdo::calculateOnlineId(sid.side, sid.rodid))
    {
      ATH_MSG_DEBUG( "Error: input TgcRdo id does not match bytestream id" );
      return;
    }
 
  //rdo.setOnlineId(sid.side, sid.rodid); // Standard data
 
  TGC_BYTESTREAM_FRAGMENTCOUNT counters[7] = {
    {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, {0, 8}, {0, 9}
  };
  TGC_BYTESTREAM_FRAGMENTCOUNT counter{};
 
  int iBs = 0;
  for(int iCnt = 0; iCnt < 7; iCnt++)
    {
      fromBS32(bs[iBs], counter);
      if(counter.id == counters[iCnt].id)
        {
      counters[iCnt].count = counter.count;
      iBs++;
        }
    }
 
  //iBs--;
  for(int iCnt = 0; iCnt < 7; iCnt++)
    {
      if(counters[iCnt].count == 0)
    continue;
      switch(counters[iCnt].id)
        {
        case 1: // Raw data format (SSW format)
      {
        ATH_MSG_VERBOSE( "fragment" << counters[iCnt].id << 
                 " " << counters[iCnt].count << "words" );
        for(unsigned iFrag = 0; iFrag < counters[iCnt].count; iFrag++)
          {
        ATH_MSG_VERBOSE( "WORD" << iFrag << ":" << MSG::hex << bs[iBs] );
        iBs++;
          }
        break;
      }
        case 2: // TgcRawData::TYPE_HIT
      {
        ATH_MSG_VERBOSE( "fragment" << counters[iCnt].id << 
                 " " << counters[iCnt].count << "words" );
        
        TGC_BYTESTREAM_READOUTHIT roh;
        for(unsigned iFrag = 0; iFrag < counters[iCnt].count; iFrag++)
          {
        ATH_MSG_VERBOSE( "WORD" << iFrag << ":" << MSG::hex << bs[iBs] );
        fromBS32(bs[iBs++], roh);
        
        ATH_MSG_VERBOSE( " rdo.subDetectorId():" << rdo.subDetectorId()
                 << " rdo.rodId():" <<rdo.rodId()
                 << " roh.ldbId:" <<roh.ldbId
                 << " roh.sbId:" <<roh.sbId
                 << " rdo.l1Id():"<<rdo.l1Id()
                 << " rdo.bcId():"<<rdo.bcId() );
 
        uint16_t slbId = roh.sbId;
                // SBLOCs for EIFI are different in online (ByteStream) and offline (RDO).
                // bug #57051: Wrong numbering of SBLOC for Inner Stations (EI/FI) in 12-fold TGC cablings
                // ByteStream : slbId = SBLOC + ip*2 (ip=0, 1, 2), SBLOC = 8 or 9 (EI), 0 or 1 (FI)
                //              slbId =  8, 10, 12,  9, 11, 13,  0,  2,  4,  1,  3,  5
                // RDO        : slbId = SBLOC + ip*4 (ip=0, 1, 2), SBLOC = 1 or 3 (EI), 0 or 2 (FI)
                //              slbId =  1,  5,  9,  3,  7, 11,  0,  4,  8,  2,  6, 10
                if(roh.sbType==TgcRawData::SLB_TYPE_INNER_WIRE ||
                   roh.sbType==TgcRawData::SLB_TYPE_INNER_STRIP) {
                  if(roh.sbId<8) slbId =  roh.sbId   *2;
                  else           slbId = (roh.sbId-8)*2+1;
                }
        
        TgcRawData* raw =  new TgcRawData(bcTag(roh.bcBitmap),
                          rdo.subDetectorId(),
                          rdo.rodId(),
                          roh.ldbId,
                          slbId,
                          rdo.l1Id(),
                          rdo.bcId(),
                          // http://cern.ch/atlas-tgc/doc/ROBformat.pdf
                          // Table 7 : SB type, bits 15..13
                          // 0,1: doublet wire, strip
                          // 2,3: triplet wire, strip triplet;
                          // 4  : inner wire and strip
                          // TgcRawData::SlbType is defined in TgcRawData.h
                          // 0: SLB_TYPE_DOUBLET_WIRE,
                          // 1: SLB_TYPE_DOUBLET_STRIP,
                          // 2: SLB_TYPE_TRIPLET_WIRE,
                          // 3: SLB_TYPE_TRIPLET_STRIP,
                          // 4: SLB_TYPE_INNER_WIRE,
                          // 5: SLB_TYPE_INNER_STRIP,
                          // 6: SLB_TYPE_UNKNOWN
                          (TgcRawData::SlbType)roh.sbType,
                          (bool)roh.adj,
                          roh.tracklet,
                          roh.channel+40);
        rdo.push_back(raw);
          }
        break;
      }
        case 3: // TgcRawData::TYPE_TRACKLET
      {
        ATH_MSG_VERBOSE( "fragment" << counters[iCnt].id << 
                 " " << counters[iCnt].count << "words" );
        TGC_BYTESTREAM_READOUTTRIPLETSTRIP rostrip;
        TGC_BYTESTREAM_READOUTTRACKLET rotrk;
        for(unsigned iFrag = 0; iFrag < counters[iCnt].count; iFrag++)
          {
        ATH_MSG_VERBOSE( "WORD" << iFrag << ":" << MSG::hex << bs[iBs] );
        fromBS32(bs[iBs], rostrip);
 
        if(rostrip.slbType == TgcRawData::SLB_TYPE_TRIPLET_STRIP)
          {
            TgcRawData* raw = new TgcRawData(bcTag(rostrip.bcBitmap),
                             rdo.subDetectorId(),
                             rdo.rodId(),
                             rostrip.ldbId,
                             rostrip.sbId,
                             rdo.l1Id(),
                             rdo.bcId(),
                             TgcRawData::SLB_TYPE_TRIPLET_STRIP,
                             0,
                             rostrip.seg,
                             rostrip.subc,
                             rostrip.phi);
            rdo.push_back(raw);
          }
        else
          {
            fromBS32(bs[iBs], rotrk);
            TgcRawData* raw = new TgcRawData(bcTag(rotrk.bcBitmap),
                             rdo.subDetectorId(),
                             rdo.rodId(),
                             rotrk.ldbId,
                             rotrk.sbId,
                             rdo.l1Id(),
                             rdo.bcId(),
                             // http://cern.ch/atlas-tgc/doc/ROBformat.pdf 
                             // Table 8 : Slave Board type, bits 30..28
                             // 0,1: doublet wire, strip
                             // 2,3: triplet wire, strip triplet; 
                             // 4,5: inner wire, strip
                             // TgcRawData::SlbType is defined in TgcRawData.h 
                             // 0: SLB_TYPE_DOUBLET_WIRE,
                             // 1: SLB_TYPE_DOUBLET_STRIP,
                             // 2: SLB_TYPE_TRIPLET_WIRE,
                             // 3: SLB_TYPE_TRIPLET_STRIP,
                             // 4: SLB_TYPE_INNER_WIRE,
                             // 5: SLB_TYPE_INNER_STRIP,
                             // 6: SLB_TYPE_UNKNOWN
                             (TgcRawData::SlbType)rotrk.slbType,
                             rotrk.delta,
                             rotrk.seg,
                             rotrk.subm,
                             rotrk.rphi);
            rdo.push_back(raw);
          }
        iBs++;
          }
        break;
      }
        case 8: // TgcRawData::TYPE_HIPT
      {
        ATH_MSG_VERBOSE( "fragment" << counters[iCnt].id << 
                 " " << counters[iCnt].count << "words" );
        TGC_BYTESTREAM_HIPT      hpt;
        TGC_BYTESTREAM_HIPT_INNER hptinner;
        for(unsigned iFrag = 0; iFrag < counters[iCnt].count; iFrag++)
          {
        ATH_MSG_VERBOSE( "WORD" << iFrag << ":" << MSG::hex << bs[iBs] );
        fromBS32(bs[iBs], hptinner);
 
        if(hptinner.sector & 4){
                  TgcRawData* raw = new TgcRawData(bcTag(hptinner.bcBitmap),
                                                   rdo.subDetectorId(),
                                                   rdo.rodId(),
                                                   rdo.l1Id(),
                                                   rdo.bcId(),
                                                   hptinner.strip,
                                                   0,
                                                   hptinner.sector,
                                                   0,
                                                   0,
                                                   0,
                                                   0,
                                                   0,
                                                   0,
                                                   hptinner.inner);
                  rdo.push_back(raw);
                }else{
                  fromBS32(bs[iBs], hpt);
                  TgcRawData* raw = new TgcRawData(bcTag(hpt.bcBitmap),
                                                   rdo.subDetectorId(),
                                                   rdo.rodId(),
                                                   rdo.l1Id(),
                                                   rdo.bcId(),
                                                   hpt.strip,
                                                   hpt.fwd,
                                                   hpt.sector,
                                                   hpt.chip,
                                                   hpt.cand,
                                                   hpt.hipt,
                                                   hpt.hitId,
                                                   hpt.sub,
                                                   hpt.delta,
                                                   0);
                  rdo.push_back(raw);
                }
                iBs++;
              }
        break;
      }
        case 9: // TgcRawData::TYPE_SL
      {
        ATH_MSG_VERBOSE( "fragment" << counters[iCnt].id << 
                 " " << counters[iCnt].count << "words" );
        TGC_BYTESTREAM_SL sl;
        for(unsigned iFrag = 0; iFrag < counters[iCnt].count; iFrag++)
          {
        ATH_MSG_VERBOSE( "WORD" << iFrag << ":" << MSG::hex << bs[iBs] );
        fromBS32(bs[iBs++], sl);
        
        TgcRawData* raw = new TgcRawData(bcTag(sl.bcBitmap),
                         rdo.subDetectorId(),
                         rdo.rodId(),
                         rdo.l1Id(),
                         rdo.bcId(),
                         sl.cand2plus,
                         static_cast<bool>(sl.fwd),
                         sl.sector,
                         sl.cand,
                         sl.sign,
                         sl.threshold,
                         sl.overlap,
                                                 sl.veto,
                         sl.roi);
        rdo.push_back(raw);
          }
        break;
      }
        default:
      ATH_MSG_VERBOSE( "Error: Muon::TGC_RodDecoder::byteStream2Rdo Unsupported fragment type "
               << counters[iCnt].id);
      break;
        }
    }
 
  ATH_MSG_VERBOSE( "Decoded " << MSG::dec << rdo.size() << " elements" );
  ATH_MSG_VERBOSE( "Muon::TGC_RodDecoder::byteStream2Rdo done" );
}
 
void Muon::TGC_RodDecoderRawdata::showStatusWords(const uint32_t source_id, const uint16_t rdoId, const int idHash, 
                          const uint32_t nstatus, const uint32_t* status) const {
  static const unsigned int maxNStatus = 5;
  static const std::string statusDataWord[maxNStatus] = {
    "First status word specific|generic:", // 0
    "TGC ROD event status              :", // 1
    "ROD VME fileter bits | SSW timeout:", // 2
    "Local status word    | presence   :", // 3
    "orbit count                       :"  // 4
  };
 
  static const unsigned int maxFirstStatus = 5;
  static const std::string firstStatus[maxFirstStatus] = {
    "incorrect BCID", // 0
    "incorrect L1AID", // 1
    "Timeout occurred in at least one of the FE links. Fragment is incomplete.", // 2 
    "Data may be incorrect, see TGC ROD event status word", // 3
    "An overflow in one of the ROD internal buffers has occurred. The fragment is incomplete." // 4
  };
 
  static const unsigned int maxTgcRodEventStatus = 31;
  static const std::string tgcRodEventStatus[maxTgcRodEventStatus] = {
    "EC_RXsend    : Error in request to send an event via RXlink", //  0
    "EC_FELdown   : A Front End link has gone down - abandoned", //  1 
    "EC_frame     : Invalid FE link framing words", //  2
    "EC_Glnk      : Front End link G-link error", //  3
    "EC_xor       : Invalid XOR event checksum", //  4
    "EC_ovfl      : Input FE event is too long or FE FIFO overflow", //  5
    "EC_timeout   : Timeout expired for at least one FE link", //  6
    "EC_xormezz   : Bad XOR checksum from mezz board", //  7
    "EC_wc0       : Event has WC=0 or WX>max WC", //  8
    "EC_L1ID      : L1ID mismatch (TTC EVID FIFO vs local).", //  9
    "EC_nohdr     : First word is not header", // 10
    "EC_rectype   : Unrecognized record type", // 11
    "EC_null      : Unexpected nulls in FE input", // 12
    "EC_order     : Word is out of order", // 13
    "EC_LDB       : Invalid or unexpected Star Switch ID", // 14
    "EC_RXovfl    : RXfifo has overflowed", // 15
    "EC_SSWerr    : SSW reports T1C, NRC, T2C, or GlinkNoLock error", // 16
    "EC_sbid      : SBid does not match SBinfo table", // 17
    "EC_SBtype    : SBtype does not match SBinfo table", // 18 
    "EC_duprx     : RX ID is duplicated in the event", // 19
    "EC_ec4       : Unexpected SB L1 Event ID(lo 4)", // 20
    "EC_bc        : Unexpected SB BCID", // 21
    "EC_celladr   : Invalid cell address", // 22
    "EC_hitovfl   : Too many hits in event", // 23
    "EC_trgbit    : Unexpected trigger bits", // 24
    "EC_badEoE    : Bad End-of-event marker received, not 0xFCA", // 25
    "EC_endWCnot0 : WC not 0 after End-of-event marker", // 26
    "EC_noEoE     : No End-of-event marker received", // 27
    "EC_SLGlink   : Sector Logic reports G-Link error", // 28 
    "EC_SLbc      : Sector Logic BCID[2:0] does not match its SB BCID", // 29 
    "EC_unxrxid   : Data from disabled SSW RX ID" // 30 
  }; 
 
  static const unsigned int maxSSWs = 12;
 
  static const unsigned int maxPresence = 10;
  static const std::string presence[maxPresence] = {
    "", // 0
    "raw data", // 1
    "hits in readout fmt", // 2
    "tracklets in readout fmt", // 3 
    "hits in chamber fmt", // 4
    "tracklets in chamber fmt", // 5 
    "", // 6
    "", // 7
    "HipT output", // 8
    "Sector Logic" // 9
  };
 
  static const unsigned int maxLocalStatus = 16;
  static const std::string localStatus[maxLocalStatus] = {
    "hit BCs are merged", //  0
    "tracklet BCs are merged", //  1
    "hits are sorted", //  2
    "tracklets are sorted", //  3 
    "", //  4
    "", //  5
    "", //  6
    "", //  7
    "", //  8
    "", //  9
    "", // 10
    "", // 11
    "", // 12
    "", // 13
    "ROI in this fragment", // 14
    "no L1AID, BCID check wrt ROD" // 15
  };
 
  ATH_MSG_INFO("***** TGC ROD STATUS WORDS for " 
           << "source_id=0x" << source_id << ", " 
           << "rdoId=0x" << rdoId << (rdoId<16 ? " , " : ", ")
           << "idHash=0x" << idHash << (idHash<16 ? " , " : ", ")
           << (idHash<12 ? "A" : "C") << (idHash%12+1<10 ? "0" : "") << std::dec << idHash%12+1 
           << " ******");
  ATH_MSG_INFO("***** Based on http://cern.ch/atlas-tgc/doc/ROBformat.pdf ****************************");
  
  for(uint32_t i=0; i<nstatus && i<maxNStatus; i++) {
    ATH_MSG_INFO(statusDataWord[i] << " status[" << i << "]=0x" << std::hex << status[i]);  
    
    if(i==0) {
      // Table 2 ATLAS standard, first status word, all zero means no known errors 
      for(unsigned int j=0; j<maxFirstStatus; j++) {
    if((status[i] >> j) & 0x1) {
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << firstStatus[j]);
    }
      }
    } else if(i==1) {
      // Table 3 TGC ROD event status word 
      for(unsigned int j=0; j<maxTgcRodEventStatus; j++) {
    if((status[i] >> j) & 0x1) { 
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << tgcRodEventStatus[j]);
    }
      }
    } else if(i==2) {
      // Table 4 Star switch time-out status and ROD VME filter bits
      for(unsigned int j=0; j<maxSSWs; j++) {
    if((status[i] >> j) & 0x1) { 
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << "time-out for SSW" << j);
    }
      }
      for(unsigned int j=0+16; j<=maxSSWs+16; j++) {
    if((status[i] >> j) & 0x1) { 
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << "data from SSW" << j-16 << " gave filter \"accept\"");
    }
      }
    } else if(i==3) {
      // Table 6 Presence bits
      for(unsigned int j=0; j<maxPresence; j++) {
    if(j==0 || j==6 || j==7) continue;
    if((status[i] >> j) & 0x1) { 
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << presence[j]);
    }
      }
      
      // Table 5 Local status word 
      for(unsigned int j=0+16; j<maxLocalStatus+16; j++) {
    if((j>=4+16 && j<=13+16)) continue;
    if((status[i] >> j) & 0x1) { 
      ATH_MSG_INFO(std::dec << std::setw(3) << j <<  " : " << localStatus[j-16]);
    }
      }
    }
  }
  
  ATH_MSG_INFO("**************************************************************************************");
}