ITkStripsRodEncoder Class Reference

Athena Algorithm Tool that provides conversion from ITkStrips RDO to ROD format Bytestream. More...

#include <ITkStripsRodEncoder.h>

Inheritance diagram for ITkStripsRodEncoder:

Collaboration diagram for ITkStripsRodEncoder:

Public Member Functions
virtual	~ITkStripsRodEncoder ()=default
	Destructor. More...
virtual StatusCode	initialize () override
	Initialize. More...
virtual void	fillROD (std::vector< uint32_t > &vec32Data, const uint32_t &robID, const std::vector< const SCT_RDORawData * > &vecRDOs) const override
	Main Convert method. More...

Private Member Functions
void	encodeData (const std::vector< uint16_t > &clusters, std::vector< uint8_t > &data_encode, int typ, uint8_t l0tag, uint8_t bc_count) const
void	packFragments (std::vector< uint8_t > &vec8Words, std::vector< uint32_t > &vec32Words) const
	Method to pack vector of 8 bit words intto a vector of 32 bit words. More...
std::vector< uint16_t >	clusterFinder (const std::bitset< 256 > &inputData, const uint8_t maxCluster=63) const
	@breif Method to set pairs of 8 bit words to a 32 bit word. More...
uint16_t	clusterFinder_sub (uint64_t &hits_high64, uint64_t &hits_low64, bool isSecondRow) const
uint32_t	set32Bits (const unsigned short int *arr8Words, const unsigned short int *position, const unsigned short int &numWords) const
bool	getBit_128b (uint8_t bit_addr, uint64_t data_high64, uint64_t data_low64) const
void	setBit_128b (uint8_t bit_addr, bool value, uint64_t &data_high64, uint64_t &data_low64) const
bool	getParity_8bits (uint8_t val) const
int	getBarrelEC (const SCT_RDORawData *rdo) const
	Get the barrel/endcape info from the RDO. More...
int	getDiskLayer (const SCT_RDORawData *rdo) const
	Get disk/layer info from the RDO. More...
int	getPhiModule (const SCT_RDORawData *rdo) const
	Get the phi value info from the RDO. More...
int	getEtaModule (const SCT_RDORawData *rdo) const
	Get the eta value info from the RDO. More...
int	getStripMax (const SCT_RDORawData *rdo) const
	Get the maxumum strip value info from the RDO. More...
int	side (const SCT_RDORawData *rdo) const
	Get the side info from the RDO. More...
int	getTimeBin (const SCT_RDORawData *rdo) const
	Get the time bin info from the RDO. More...
int	getStrip (const SCT_RDORawData *rdo) const
	Get the strip number info from the RDO. More...
Identifier	offlineID (const SCT_RDORawData *rdo) const
	Get the offline Identifier from the RDO. More...
uint32_t	onlineID (const SCT_RDORawData *rdo) const
	Get the online Identifier from the RDO. More...
int	getRODLink (const SCT_RDORawData *rdo) const
	Get the ROD link number info in the RDO header data. More...
uint16_t	getHeaderPhysicsPacket (int typ, uint8_t l0tag, uint8_t bc_count) const
	Get the 16-bit word for a header with Type (PR or LP), L0Tag event and BCID. More...
uint16_t	getHeaderUsingRDO (const SCT_RDORawData *rdo) const
	Get the 16-bit word for a header for a hit. More...
uint16_t	getHeaderUsingHash (const IdentifierHash &linkHash, const int &errorWord) const
	Get the 16-bit word for a header for a link with a ByteStream error. More...
uint16_t	getTrailer (const int &errorWord) const
	Get the 16-bit word for a trailer, with or without ByteStream errors. More...

Private Attributes
std::atomic< uint8_t >	m_bcid = 0
	Method to encode RDO data to vector of 16 bin words. More...
std::atomic< uint8_t >	m_l0tag = 0
ToolHandle< IITkStripCablingTool >	m_cabling
	Providing mappings of online and offline identifiers and also serial numbers. More...
const SCT_ID *	m_itkStripsID {nullptr}
	Identifier helper class for the ITkStrips subdetector that creates compact Identifier objects and IdentifierHash or hash IDs. More...
BooleanProperty	m_condensed {this, "CondensedMode", false, "Condensed mode (true) or Expanded mode (false)"}
	Example Boolean used to determine decoding mode, maybe unused finally. More...
std::set< Identifier >	m_swapModuleID {}
	Swap Module identifier, set by SCTRawContByteStreamTool. More...

Detailed Description

Athena Algorithm Tool that provides conversion from ITkStrips RDO to ROD format Bytestream.

Definition at line 29 of file ITkStripsRodEncoder.h.

Constructor & Destructor Documentation

~ITkStripsRodEncoder()

virtual ITkStripsRodEncoder::~ITkStripsRodEncoder ( )

virtualdefault

Destructor.

Member Function Documentation

clusterFinder()

std::vector< uint16_t > ITkStripsRodEncoder::clusterFinder ( const std::bitset< 256 > &  inputData, const uint8_t  maxCluster = 63  ) const

private

@breif Method to set pairs of 8 bit words to a 32 bit word.

Function used by the packFragments(...) method.

Parameters

arr8Words	Pointer to array containing a pair of 8 bit words.
position	Pointer to an array that gives the 32 bit starting positions of the 8 bit words and corresponding to arr8Words.
numWords	Number of word to be set to a 32 bit word.

Definition at line 161 of file ITkStripsRodEncoder.cxx.

                                                                                                  {
 
  std::vector<uint16_t> clusters;
 
  // Split the 256-bit input data into four 64-bit chunks for processing
  uint64_t d0l = chunk<0>(inputData);
  uint64_t d0h = chunk<1>(inputData);
 
  uint64_t d1l = chunk<2>(inputData);
  uint64_t d1h = chunk<3>(inputData);
 
  while (d0l or d0h or d1l or d1h){
    if (clusters.size() > maxCluster) break;
 
    uint16_t cluster1 = clusterFinder_sub(d1h, d1l, true);
    if (cluster1 != 0x3ff) // No cluster was found
      clusters.push_back(cluster1);
 
    if (clusters.size() > maxCluster) break;
 
    uint16_t cluster0 = clusterFinder_sub(d0h, d0l, false);
    if (cluster0 != 0x3ff) // No cluster was found
      clusters.push_back(cluster0);
  }
 
  if (clusters.empty()) {
    clusters.push_back(0x3fe);
  } else {
    clusters.back() |=1 << 11;
  }
 
  return clusters;
}

clusterFinder_sub()

uint16_t ITkStripsRodEncoder::clusterFinder_sub ( uint64_t &  hits_high64, uint64_t &  hits_low64, bool  isSecondRow  ) const

private

Definition at line 214 of file ITkStripsRodEncoder.cxx.

                                                                                                          {
  uint8_t hit_addr = 128;
  uint8_t hitpat_next3 = 0;
 
  if (hits_low64){
    hit_addr = __builtin_ctzll(hits_low64);
  } else if (hits_high64){
    hit_addr = __builtin_ctzll(hits_high64) + 64;
  }
 
  hitpat_next3 = getBit_128b(hit_addr+1, hits_high64, hits_low64) << 2
    | getBit_128b(hit_addr+2, hits_high64, hits_low64) << 1
    | getBit_128b(hit_addr+3, hits_high64, hits_low64);
 
  for (int i=0; i<4; ++i)
    setBit_128b(hit_addr+i, 0, hits_high64, hits_low64);
 
  if (hit_addr == 128) {
    return 0x3ff;
  } else {
    hit_addr += isSecondRow<<7;
    return hit_addr << 3 | hitpat_next3;
  }
}

encodeData()

void ITkStripsRodEncoder::encodeData ( const std::vector< uint16_t > &  clusters, std::vector< uint8_t > &  data_encode, int  typ, uint8_t  l0tag, uint8_t  bc_count  ) const

private

Definition at line 130 of file ITkStripsRodEncoder.cxx.

                                                                                 {
 
  uint16_t header = getHeaderPhysicsPacket(ptyp, l0tag, bc_count);
 
  data_encode.push_back((header>>8) & 0xff);
  data_encode.push_back(header & 0xff);
 
  size_t cluster_count = 0;
  for ( uint16_t cluster : clusters) {
    if (cluster_count == 4){
      // Max number of clusters per package 4 
      break;
    }
 
    uint16_t clusterbits = cluster & 0x7ff;
    data_encode.push_back((clusterbits>>8) & 0xff);
    data_encode.push_back(clusterbits & 0xff);
    cluster_count++;
  }
  
  while (cluster_count < 4) {
        data_encode.push_back(0x7F);  // Cluster empty (0x7FF in 12 bits)
        data_encode.push_back(0xFF);
        cluster_count++;
    }
 
  return;
}

fillROD()

void ITkStripsRodEncoder::fillROD ( std::vector< uint32_t > &  vec32Data, const uint32_t &  robID, const std::vector< const SCT_RDORawData * > &  vecRDOs  ) const

overridevirtual

Main Convert method.

Converts SCT RDO to a vector of 32 bit words. Starts by retrieving and collecting errors, then loops through RDO's and decode them to 16 bit words, and then finally it packs the 16 bit word into 32 bit words vector.

Parameters

vec32Data	Vector of 32 bit words to be filled with encoded RDOs from the SCT.
robID	ID of the current readout buffer (ROB).
vecRDOs	Vector containing the RDOs to be coverted to vector of 32 bit words.

Definition at line 67 of file ITkStripsRodEncoder.cxx.

                                                                                    {
  //code to be filled here
 
  std::unordered_map<uint64_t, std::vector<std::bitset<256>>> allStripData;
  
  for (const auto& rdo : vecRDOs) {
    int barrel = getBarrelEC(rdo);
    int disk = getDiskLayer(rdo);
    int phi_mod = getPhiModule(rdo);
    int eta_mod = getEtaModule(rdo);
    int strip_max = getStripMax(rdo);
    
    if (strip_max < 0){
      continue; 
    }
    int eta_group;
 
    if (barrel == 0) {
      eta_group = static_cast<int>(std::floor((eta_mod+1) / 2)); //To work with barrel
    }else {
      eta_group = static_cast<int>(std::floor(eta_mod / 2)); //To work with endcap
    }
 
    int chips_per_module = (strip_max + 1) / 128;
    uint64_t key = geometryKey(barrel, disk, phi_mod, eta_group);
    auto& StripData = allStripData[key];
 
    if (StripData.empty()) {
      StripData.resize(chips_per_module);
    }
     
    //Populate the bitset for each chip with active strips
    int strip = getStrip(rdo);
    int chip = static_cast<int>(std::floor(strip / 128));
    int strip_position = strip % 128;
    int strip_logical_channel = 2*strip_position + (eta_mod & 1);
    StripData[chip].set(strip_logical_channel);
  }
 
  std::vector<uint8_t> vec8Data;
  vec8Data.reserve(10);
 
  //Iterate over processed strip data and find clusters
  for (const auto& [key, StripData] : allStripData) {
    int ptype = 1;
    for (size_t i = 0; i < StripData.size(); ++i) {
      if (StripData[i].any()) {
              std::bitset<256> hits = StripData[i];
        //Use clusterFinder to extract clusters from the bitset
        std::vector<uint16_t> clusters = clusterFinder(hits);
        encodeData(clusters, vec8Data, ptype, m_l0tag , m_bcid);
      }
    }
    //Update BCID and L0Tag counters
    m_bcid = (m_bcid + 1) & 0x7F;
    m_l0tag = (m_l0tag + 1) & 0x7F;
  }
  packFragments(vec8Data,vec32Data);
  return;
}

getBarrelEC()

int ITkStripsRodEncoder::getBarrelEC ( const SCT_RDORawData *  rdo ) const

private

Get the barrel/endcape info from the RDO.

Definition at line 313 of file ITkStripsRodEncoder.cxx.

                                                               {
  const Identifier rdoID{rdo->identify()};
  int itkBarrel{m_itkStripsID->barrel_ec(rdoID)};
  return itkBarrel;
}

getBit_128b()

bool ITkStripsRodEncoder::getBit_128b ( uint8_t  bit_addr, uint64_t  data_high64, uint64_t  data_low64  ) const

inlineprivate

Definition at line 196 of file ITkStripsRodEncoder.cxx.

                                                                                                  {
  if (bit_addr > 127) return false;
 
  return bit_addr<64 ? data_low64>>bit_addr & 1 : data_high64>>(bit_addr-64) & 1;
}

getDiskLayer()

int ITkStripsRodEncoder::getDiskLayer ( const SCT_RDORawData *  rdo ) const

private

Get disk/layer info from the RDO.

Definition at line 320 of file ITkStripsRodEncoder.cxx.

                                                                {
  const Identifier rdoID{rdo->identify()};
  int itkDiskLayer{m_itkStripsID->layer_disk(rdoID)};
  return itkDiskLayer;
}

getEtaModule()

int ITkStripsRodEncoder::getEtaModule ( const SCT_RDORawData *  rdo ) const

private

Get the eta value info from the RDO.

Definition at line 334 of file ITkStripsRodEncoder.cxx.

                                                                {
  const Identifier rdoID{rdo->identify()};
  int itkEtaModule{m_itkStripsID->eta_module(rdoID)};
  return itkEtaModule;
}

getHeaderPhysicsPacket()

uint16_t ITkStripsRodEncoder::getHeaderPhysicsPacket ( int  typ, uint8_t  l0tag, uint8_t  bc_count  ) const

private

Get the 16-bit word for a header with Type (PR or LP), L0Tag event and BCID.

Definition at line 356 of file ITkStripsRodEncoder.cxx.

                                                                                         {
  uint8_t bcid_low = bc_cout & 0x7; // BCID[2:0]
  bool bc_parity = getParity_8bits(bc_cout);
  //TYPE (4 bits) + FlagBit (1 bit) + L0tag (7 bits) + BCID (3 bits) + Parity (1 bit)
  const uint16_t Header{static_cast<uint16_t>(((uint8_t)typ << 12) | (0x1 << 11) | (l0tag & 0x7f) << 4 | (bcid_low) << 1 | bc_parity)};
  return Header;
  
}

getHeaderUsingHash()

uint16_t ITkStripsRodEncoder::getHeaderUsingHash ( const IdentifierHash &  linkHash, const int &  errorWord  ) const

private

Get the 16-bit word for a header for a link with a ByteStream error.

Definition at line 375 of file ITkStripsRodEncoder.cxx.

                                                                                                  {
  const int rodLink{rodLinkFromOnlineID(m_cabling->getOnlineIdFromHash(linkHash))};
  const uint16_t linkHeader{static_cast<uint16_t>(0x2000 | errorWord | (m_condensed.value() << 8) | rodLink)};
  return linkHeader;
}

getHeaderUsingRDO()

uint16_t ITkStripsRodEncoder::getHeaderUsingRDO ( const SCT_RDORawData *  rdo ) const

private

Get the 16-bit word for a header for a hit.

Definition at line 368 of file ITkStripsRodEncoder.cxx.

                                                                      {
  const int rodLink{getRODLink(rdo)};
  const uint16_t linkHeader{static_cast<uint16_t>(0x2000 | (m_condensed.value() << 8) | rodLink)};
  return linkHeader;
}

getParity_8bits()

bool ITkStripsRodEncoder::getParity_8bits ( uint8_t  val ) const

private

Definition at line 348 of file ITkStripsRodEncoder.cxx.

                                                     {
  val ^= val >> 4;
  val ^= val >> 2;
  val ^= val >> 1;
  return val&1;
}

getPhiModule()

int ITkStripsRodEncoder::getPhiModule ( const SCT_RDORawData *  rdo ) const

private

Get the phi value info from the RDO.

Definition at line 327 of file ITkStripsRodEncoder.cxx.

                                                                {
  const Identifier rdoID{rdo->identify()};
  int itkPhiModule{m_itkStripsID->phi_module(rdoID)};
  return itkPhiModule;
}

getRODLink()

int ITkStripsRodEncoder::getRODLink ( const SCT_RDORawData *  rdo ) const

private

Get the ROD link number info in the RDO header data.

Definition at line 301 of file ITkStripsRodEncoder.cxx.

                                                               {
  return rodLinkFromOnlineID(onlineID(rdo));
}

getStrip()

int ITkStripsRodEncoder::getStrip ( const SCT_RDORawData *  rdo ) const

private

Get the strip number info from the RDO.

Definition at line 282 of file ITkStripsRodEncoder.cxx.

                                                             {
  const Identifier rdoID{rdo->identify()};
  return m_itkStripsID->strip(rdoID);
}

getStripMax()

int ITkStripsRodEncoder::getStripMax ( const SCT_RDORawData *  rdo ) const

private

Get the maxumum strip value info from the RDO.

Definition at line 341 of file ITkStripsRodEncoder.cxx.

                                                               {
  const Identifier rdoID{rdo->identify()};
  int itkStripMax{m_itkStripsID->strip_max(rdoID)};
  return itkStripMax;
}

getTimeBin()

int ITkStripsRodEncoder::getTimeBin ( const SCT_RDORawData *  rdo ) const

private

Get the time bin info from the RDO.

getTrailer()

uint16_t ITkStripsRodEncoder::getTrailer ( const int &  errorWord ) const

private

Get the 16-bit word for a trailer, with or without ByteStream errors.

Definition at line 382 of file ITkStripsRodEncoder.cxx.

                                                          {
  const uint16_t linkTrailer{static_cast<uint16_t>(0x4000 | errorWord)};
  return linkTrailer;
}

initialize()

StatusCode ITkStripsRodEncoder::initialize ( )

overridevirtual

Initialize.

Definition at line 45 of file ITkStripsRodEncoder.cxx.

                                {
  ATH_MSG_DEBUG("ITkStripsRodEncoder::initialize()");
 
  // Retrieve cabling tool
  ATH_CHECK(m_cabling.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_cabling);
  ATH_CHECK(detStore()->retrieve(m_itkStripsID, "SCT_ID"));
  const InDetDD::SCT_DetectorManager* itkStripsDetManager{nullptr};
  ATH_CHECK(detStore()->retrieve(itkStripsDetManager, "ITkStrip"));
  const InDetDD::SiDetectorElementCollection* sctDetElementColl{itkStripsDetManager->getDetectorElementCollection()};
  for (const InDetDD::SiDetectorElement* sctDetElement : *sctDetElementColl) {
    if (sctDetElement->swapPhiReadoutDirection()) {
      m_swapModuleID.insert(sctDetElement->identify());
    }
  }
  ATH_MSG_DEBUG("Initialization was successful");
  return StatusCode::SUCCESS;
}

offlineID()

Identifier ITkStripsRodEncoder::offlineID ( const SCT_RDORawData *  rdo ) const

private

Get the offline Identifier from the RDO.

Definition at line 288 of file ITkStripsRodEncoder.cxx.

                                                              {
  const Identifier rdoId{rdo->identify()};
  return m_itkStripsID->wafer_id(rdoId);
}

onlineID()

uint32_t ITkStripsRodEncoder::onlineID ( const SCT_RDORawData *  rdo ) const

private

Get the online Identifier from the RDO.

Definition at line 294 of file ITkStripsRodEncoder.cxx.

                                                             {
  const Identifier waferID{offlineID(rdo)};
  const IdentifierHash offlineIDHash{m_itkStripsID->wafer_hash(waferID)};
  return static_cast<uint32_t>(m_cabling->getOnlineIdFromHash(offlineIDHash));
}

packFragments()

void ITkStripsRodEncoder::packFragments ( std::vector< uint8_t > &  vec8Words, std::vector< uint32_t > &  vec32Words  ) const

private

Method to pack vector of 8 bit words intto a vector of 32 bit words.

Method us used by private method encodeData(...).

Parameters

vec8Words	Vector containing 8 bit words.
vec32Words	Vector for 32 bit words to be packed.

Definition at line 240 of file ITkStripsRodEncoder.cxx.

                                                                                                       {
  int num8Words{static_cast<int>(vec8Words.size())};
  if (num8Words % 4 != 0) {
    // Just add additional 8-bit words to make the size a multiple of 4
    while (num8Words % 4 != 0) {
      vec8Words.push_back(0x40); // Padding byte
      num8Words++;
    }
  }  
  // Now merge 4 consecutive 8-bit words into 32-bit words
  const unsigned short int numWords{4};
  const unsigned short int position[numWords]{0, 8, 16, 24};
  unsigned short int arr8Words[numWords]{0, 0, 0, 0};
  
  for (int i{0}; i<num8Words; i += numWords) {
    for (int j{0}; j<numWords; j++) {
      arr8Words[j] = vec8Words[i + j];
    }
    const uint32_t uint32Word{set32Bits(arr8Words, position, numWords)};
    vec32Words.push_back(uint32Word);
  }
  return;
}

set32Bits()

uint32_t ITkStripsRodEncoder::set32Bits ( const unsigned short int *  arr8Words, const unsigned short int *  position, const unsigned short int &  numWords  ) const

private

Definition at line 266 of file ITkStripsRodEncoder.cxx.

{
  uint32_t uint32Word{0};
  uint32_t pos{0};
  uint32_t uint8Word{0}; 
  for (uint16_t i{0}; i<numWords; i++) {
    uint8Word = static_cast<uint32_t>(*(arr8Words + i));
    pos = static_cast<uint32_t>(*(position + i));
    uint32Word |= (uint8Word << pos); // Shift the 8-bit word to its correct position and merge
  } 
  return uint32Word;
}

setBit_128b()

void ITkStripsRodEncoder::setBit_128b ( uint8_t  bit_addr, bool  value, uint64_t &  data_high64, uint64_t &  data_low64  ) const

inlineprivate

Definition at line 203 of file ITkStripsRodEncoder.cxx.

                                                                                                                 {
  if (bit_addr < 64) {
    data_low64 = (data_low64 & ~(1ULL << bit_addr)) | ((uint64_t)value << bit_addr);
  } else if (bit_addr < 128) {
    data_high64 =
      (data_high64 & ~(1ULL << (bit_addr-64))) | ((uint64_t)value << (bit_addr-64));
  }
}

side()

int ITkStripsRodEncoder::side ( const SCT_RDORawData *  rdo ) const

private

Get the side info from the RDO.

Definition at line 306 of file ITkStripsRodEncoder.cxx.

                                                         {
  const Identifier rdoID{rdo->identify()};
  int itkSide{m_itkStripsID->side(rdoID)};
  return itkSide;
}

Member Data Documentation

m_bcid

std::atomic<uint8_t> ITkStripsRodEncoder::m_bcid = 0

mutableprivate

Method to encode RDO data to vector of 16 bin words.

Methods used by main convert methods fillROD(...).

Parameters

vecTimeBins	Vector of time bins for RDOs.
vec16Words	Vector of 16 bit words to filled from encoded RDO data.
rdo	RDO raw data object to be encoded.
groupSize	Group size info from the RDO.
strip	Strip number info from the RDO.

Definition at line 70 of file ITkStripsRodEncoder.h.

m_cabling

ToolHandle<IITkStripCablingTool> ITkStripsRodEncoder::m_cabling

private

Initial value:

{this, 
                                         "ITkStripCablingTool", 
                                         "ITkStripCablingTool", 
                                         "Tool to retrieve ITkStrips Cabling"}

Providing mappings of online and offline identifiers and also serial numbers.

Definition at line 152 of file ITkStripsRodEncoder.h.

m_condensed

BooleanProperty ITkStripsRodEncoder::m_condensed {this, "CondensedMode", false, "Condensed mode (true) or Expanded mode (false)"}

private

Example Boolean used to determine decoding mode, maybe unused finally.

Definition at line 162 of file ITkStripsRodEncoder.h.

m_itkStripsID

const SCT_ID* ITkStripsRodEncoder::m_itkStripsID {nullptr}

private

Identifier helper class for the ITkStrips subdetector that creates compact Identifier objects and IdentifierHash or hash IDs.

Also allows decoding of these IDs.

Definition at line 159 of file ITkStripsRodEncoder.h.

m_l0tag

std::atomic<uint8_t> ITkStripsRodEncoder::m_l0tag = 0

mutableprivate

Definition at line 71 of file ITkStripsRodEncoder.h.

m_swapModuleID

std::set<Identifier> ITkStripsRodEncoder::m_swapModuleID {}

private

Swap Module identifier, set by SCTRawContByteStreamTool.

Definition at line 165 of file ITkStripsRodEncoder.h.

---

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

• ITkStripsRodEncoder.h
• ITkStripsRodEncoder.cxx