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.
virtual StatusCode	initialize () override
	Initialize.
virtual void	fillROD (std::vector< uint32_t > &vec32Data, const uint32_t &robID, const std::vector< const SCT_RDORawData * > &vecRDOs) const override
	Main Convert method.

Private Member Functions
bool	isNear (const int &eta_mod, bool isBarrel=false) const
void	encodeData (const std::vector< uint16_t > &clusters, const uint16_t ichannel, std::vector< uint8_t > &data_encode, int typ, uint8_t l0tag, uint8_t bc_count, uint32_t hccKey, uint16_t &size) 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.
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.
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.
uint8_t	getDiskLayer (const SCT_RDORawData *rdo) const
	Get disk/layer info from the RDO.
uint8_t	getPhiModule (const SCT_RDORawData *rdo) const
	Get the phi value info from the RDO.
int	getEtaModule (const SCT_RDORawData *rdo) const
	Get the eta value info from the RDO.
uint16_t	getStripMax (const SCT_RDORawData *rdo) const
	Get the maxumum strip value info from the RDO.
int	getSide (const SCT_RDORawData *rdo) const
	Get the side info from the RDO.
int	getTimeBin (const SCT_RDORawData *rdo) const
	Get the time bin info from the RDO.
int	getStrip (const SCT_RDORawData *rdo) const
	Get the strip number info from the RDO.
Identifier	offlineID (const SCT_RDORawData *rdo) const
	Get the offline Identifier from the RDO.
uint32_t	onlineID (const SCT_RDORawData *rdo, const EventContext &ctx) const
	Get the online Identifier from the RDO.
int	getRODLink (const SCT_RDORawData *rdo, const EventContext &ctx) const
	Get the ROD link number info in the RDO header data.
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.
uint16_t	getHeaderUsingRDO (const SCT_RDORawData *rdo, const EventContext &ctx) const
	Get the 16-bit word for a header for a hit.
uint16_t	getHeaderUsingHash (const IdentifierHash &linkHash, const int &errorWord, const EventContext &ctx) const
	Get the 16-bit word for a header for a link with a ByteStream error.
uint16_t	getTrailer (const int &errorWord) const
	Get the 16-bit word for a trailer, with or without ByteStream errors.

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

Detailed Description

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

Definition at line 31 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 304 of file ITkStripsRodEncoder.cxx.

                                                                                                  {
 
  std::vector<uint16_t> clusters;
  
  // Split into far (odd) and near (even) strips
  std::bitset<128> dataEven;
  std::bitset<128> dataOdd;
  for(int i=0; i<128; ++i){
    dataEven[i] = inputData[2*i];
    dataOdd[i] = inputData[2*i+1];
  }
 
  // Split the 128-bit Even and Odd data into four 64-bit chunks for processing
  uint64_t d0l = chunk<0>(dataEven);
  uint64_t d0h = chunk<1>(dataEven);
 
  uint64_t d1l = chunk<0>(dataOdd);
  uint64_t d1h = chunk<1>(dataOdd);
 
  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 365 of file ITkStripsRodEncoder.cxx.

                                                                                                          {
  uint8_t hit_addr = 128;
  uint8_t hit_mask = 0;
 
  if (hits_low64){
    hit_addr = __builtin_ctzll(hits_low64);
  } else if (hits_high64){
    hit_addr = __builtin_ctzll(hits_high64) + 64;
  }
 
  hit_mask = 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 | hit_mask;
  }
}

encodeData()

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

private

Definition at line 264 of file ITkStripsRodEncoder.cxx.

                                                                                                                  {
 
 
  if(hccKey!=0){
    ATH_MSG_DEBUG("hccKey: " << std::bitset<32>(hccKey));
    ATH_MSG_DEBUG("hccKey 8-bit word-4: "<<std::bitset<8>(hccKey));        
    ATH_MSG_DEBUG("hccKey 8-bit word-3: "<<std::bitset<8>(hccKey>>24));
    ATH_MSG_DEBUG("hccKey 8-bit word-2: "<<std::bitset<8>(hccKey>>16));    
    ATH_MSG_DEBUG("hccKey 8-bit word-1: "<<std::bitset<8>(hccKey>>8));
 
    data_encode.push_back(hccKey);    
    data_encode.push_back(hccKey>>24);
    data_encode.push_back(hccKey>>16);
    data_encode.push_back(hccKey>>8);
 
    uint16_t header = getHeaderPhysicsPacket(ptyp, l0tag, bc_count);
    ATH_MSG_DEBUG("header: " << std::bitset<16>(header));
    data_encode.push_back((header>>8) & 0xff);
    data_encode.push_back(header & 0xff);
  }  
 
  for(size_t idx=0;auto &cluster : clusters){
    if(cluster == 0x3fe) continue;
    if(idx!=0) size++;
    
    // cluster bits:
    // "0" + 4-bit channel number + 11-bit cluster dropping the last cluster bit    
    uint16_t clusterbits = ((ichannel & 0xf) << 11) | (cluster & 0x7ff);
    ATH_MSG_DEBUG("Clusters: " << idx << ": " << std::bitset<16>(clusterbits) << " size: " << size << " ichannel: " << ichannel);    
    data_encode.push_back((clusterbits>>8) & 0xff);
    data_encode.push_back(clusterbits & 0xff);
    idx++;    
  }
  
  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 120 of file ITkStripsRodEncoder.cxx.

                                                                                    {
  //code to be filled here
 
  std::unordered_map<uint32_t, std::vector<std::bitset<256>>> allStripData;
  std::unordered_map<uint32_t, IdentifierHash> keyToHash;  
 
  IdentifierHash offlineHash = 0;
  
  for (const auto& rdo : vecRDOs) {
    int barrelEC = getBarrelEC(rdo);
    int eta_mod = getEtaModule(rdo);    
    uint8_t side = getSide(rdo);    
    uint8_t disk = getDiskLayer(rdo);
    uint8_t phi_mod = getPhiModule(rdo);
    uint16_t strip_max = getStripMax(rdo);
    
    if (strip_max == 0xFFFF){
      //To do: Implement workaround
      const Identifier rdoID{rdo->identify()};
      ATH_MSG_WARNING("Negative maximum number of strips found " << m_itkStripsID->strip_max(rdoID));
      continue; 
    }
 
    uint8_t sideAC = 0;
    if((barrelEC == 0 && eta_mod > 0) || barrelEC > 0) sideAC = 1;
 
    uint8_t eta_group=0;
 
    if (barrelEC == 0) {      
      if(disk < 2){
        eta_group = static_cast<uint8_t>(std::floor((std::abs(eta_mod)-1) / 4));
      }else{
        eta_group = static_cast<uint8_t>(std::floor((std::abs(eta_mod)-1) / 2));     
      }
    }else {
      if(eta_mod>=0 && eta_mod<=9) eta_group = static_cast<uint8_t>(std::floor(eta_mod / 4));
      else if(eta_mod>=10 && eta_mod<=13) eta_group = static_cast<uint8_t>(std::floor((eta_mod+2)/4));
      else if(eta_mod>13) eta_group = static_cast<uint8_t>(std::floor((eta_mod-6)/2));      
    }    
 
    uint8_t chips_per_module = (strip_max + 1) / 128;
    uint32_t key = hccKey(barrelEC, side, disk, phi_mod, eta_mod, eta_group);
 
    offlineHash = m_itkStripsID->wafer_hash(offlineID(rdo));
    keyToHash.insert({key,offlineHash});
    ATH_MSG_DEBUG("barrel: "<< barrelEC<<" sideAC: " << (uint32_t)sideAC << " disk: "<<(uint32_t)disk << " side: " << (uint32_t)side <<" phi_mod: "<<(uint32_t)phi_mod << " eta_mod: " << eta_mod << " eta group: "<<(uint32_t)eta_group << " chips per module: " << (uint32_t)chips_per_module << " " << (uint32_t)robID << " " << (uint32_t)m_itkStripsID->wafer_hash(offlineID(rdo)));
    ATH_MSG_DEBUG("key: " << std::bitset<32>(key));
    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 + (isNear(eta_mod, barrelEC == 0)? 0 : 1);
 
    ATH_MSG_DEBUG("strip N: "<< strip << " chip n: " << chip << " Strip position: " << strip_position << " Strip position logical: " << strip_logical_channel);
    StripData[chip].set(strip_logical_channel);
  }
 
  std::vector<uint8_t> vec8Data;
  uint32_t vectorSize = 0;
  std::vector<uint16_t> clusters;
  
  ATH_MSG_DEBUG("All strip data size: " << allStripData.size());
 
  //Iterate over processed strip data and find clusters
  for (const auto& [key, StripData] : allStripData) {
    
    uint16_t ichannel = 0;
    uint16_t size = 1;
    int ptype = 1;
    bool keyRecorded = false;
    clusters.clear();
    
    ATH_MSG_DEBUG("key is: " << std::bitset<32>(key) << " StripData size: " << StripData.size());
    
    for (size_t i = 0; i < StripData.size(); ++i) {
      
      std::bitset<256> hits = StripData[i];
      
      if(hits==0){
        ++ichannel;
        continue;
      }
 
      //Use clusterFinder to extract clusters from the bitset
      clusters = clusterFinder(hits);
      
      if(clusters.empty()){
        ++ichannel;
        continue;
      } 
      uint32_t hccKey = (keyRecorded) ? 0 : key;        
      encodeData(clusters, ichannel, vec8Data, ptype, m_l0tag , m_bcid, hccKey, size);
      keyRecorded = true;      
      ++ichannel;++size;
    }
    vec8Data.push_back(0xed);
    vec8Data.push_back(0x6f);
    ATH_MSG_DEBUG("Add 16-0s: " << size % 2 << " " << vec8Data.size());
 
    if(size % 2 == 0){
      vec8Data.push_back(0);
      vec8Data.push_back(0);
    }
    uint32_t packetLenght = (vec8Data.size()-vectorSize)+4;
    ATH_MSG_DEBUG("Packet Lenght: " << (uint32_t)packetLenght << " " << std::bitset<32>(packetLenght));
 
    std::vector<uint8_t> pktlenght = split32bitWord(packetLenght);
 
    ATH_MSG_DEBUG("PktLenght: " << pktlenght.size() << " vec8Data size: " << vec8Data.size());
 
    uint32_t offset = vectorSize + 4;
    vec8Data.insert(vec8Data.begin()+offset, pktlenght.begin(), pktlenght.end());
    vectorSize   = vec8Data.size();
    
    ATH_MSG_DEBUG("vec8Data size: " << vec8Data.size() << " size: " << size-1);
    packFragments(vec8Data,vec32Data);
    if (not m_dataRateMonTool.empty()) {
      m_dataRateMonTool->fill(keyToHash[key], vec32Data, allStripData[key]);
    }
    vec32Data.clear();
  }
 
  //Update BCID and L0Tag counters
  m_bcid = (m_bcid + 1) & 0x7F;
  m_l0tag = (m_l0tag + 1) & 0x7F;
 
  ATH_MSG_DEBUG("vec8Data size: " << vec8Data.size());
 
  packFragments(vec8Data,vec32Data);  
 
  for(auto &word: vec32Data){    
    ATH_MSG_DEBUG("32-bit word: " << std::bitset<32>(word));    
  }
  return;
}

getBarrelEC()

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

private

Get the barrel/endcape info from the RDO.

Definition at line 464 of file ITkStripsRodEncoder.cxx.

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

getBit_128b()

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

inlineprivate

Definition at line 347 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()

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

private

Get disk/layer info from the RDO.

Definition at line 470 of file ITkStripsRodEncoder.cxx.

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

getEtaModule()

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

private

Get the eta value info from the RDO.

Definition at line 482 of file ITkStripsRodEncoder.cxx.

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

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 503 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 EventContext & ctx ) const

private

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

Definition at line 522 of file ITkStripsRodEncoder.cxx.

                                                                                                                           {
  const int rodLink{rodLinkFromOnlineID(m_cabling->getOnlineIdFromHash(linkHash, ctx))};
  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 EventContext & ctx ) const

private

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

Definition at line 515 of file ITkStripsRodEncoder.cxx.

                                                                                               {
  const int rodLink{getRODLink(rdo, ctx)};
  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 495 of file ITkStripsRodEncoder.cxx.

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

getPhiModule()

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

private

Get the phi value info from the RDO.

Definition at line 476 of file ITkStripsRodEncoder.cxx.

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

getRODLink()

int ITkStripsRodEncoder::getRODLink ( const SCT_RDORawData * rdo, const EventContext & ctx ) const

private

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

Definition at line 452 of file ITkStripsRodEncoder.cxx.

                                                                                        {
  return rodLinkFromOnlineID(onlineID(rdo, ctx));
}

getSide()

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

private

Get the side info from the RDO.

Definition at line 457 of file ITkStripsRodEncoder.cxx.

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

getStrip()

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

private

Get the strip number info from the RDO.

Definition at line 433 of file ITkStripsRodEncoder.cxx.

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

getStripMax()

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

private

Get the maxumum strip value info from the RDO.

Definition at line 488 of file ITkStripsRodEncoder.cxx.

                                                               {
  const Identifier rdoID{rdo->identify()};
  if(m_itkStripsID->strip_max(rdoID)<0) return 0xFFFF;
  return m_itkStripsID->strip_max(rdoID);
}

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 529 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 94 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());
    }
  }
 
  if (not m_dataRateMonTool.empty())
      ATH_CHECK(m_dataRateMonTool.retrieve());
  
  ATH_MSG_DEBUG("Initialization was successful");
  return StatusCode::SUCCESS;
}

isNear()

bool ITkStripsRodEncoder::isNear ( const int & eta_mod, bool isBarrel = false ) const

inlineprivate

Definition at line 75 of file ITkStripsRodEncoder.h.

                                                            {
    if (isBarrel){
      int pos = std::abs(eta_mod) % 4;
      return (pos == 2 || pos == 3);
    }else{
      int pos = std::abs(eta_mod) % 4;
      if (eta_mod >= 10) pos = (eta_mod + 2) % 4;
      if (eta_mod >= 16) pos = (eta_mod + 4) % 4;
      return (pos == 1 || pos == 2);
    }
  }

offlineID()

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

private

Get the offline Identifier from the RDO.

Definition at line 439 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 EventContext & ctx ) const

private

Get the online Identifier from the RDO.

Definition at line 445 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, ctx));
}

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 391 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 417 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 354 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));
  }
}

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 72 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 167 of file ITkStripsRodEncoder.h.

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

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 179 of file ITkStripsRodEncoder.h.

{this, "CondensedMode", false, "Condensed mode (true) or Expanded mode (false)"};

m_dataRateMonTool

ToolHandle<ITkStripDataRateMonTool> ITkStripsRodEncoder::m_dataRateMonTool {this, "DataRateMonitoringTool", "", "Monitoring tool for data rate evaluation"}

private

Definition at line 172 of file ITkStripsRodEncoder.h.

{this, "DataRateMonitoringTool", "", "Monitoring tool for data rate evaluation"};  

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 176 of file ITkStripsRodEncoder.h.

{nullptr};

m_l0tag

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

mutableprivate

Definition at line 73 of file ITkStripsRodEncoder.h.

m_swapModuleID

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

private

Swap Module identifier, set by SCTRawContByteStreamTool.

Definition at line 182 of file ITkStripsRodEncoder.h.

{};

---

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

• ITkStripsRodEncoder.h
• ITkStripsRodEncoder.cxx