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

#include <SCT_RodEncoder.h>

Inheritance diagram for SCT_RodEncoder:

Collaboration diagram for SCT_RodEncoder:

Public Member Functions
	SCT_RodEncoder (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~SCT_RodEncoder ()=default
	Destructor.
virtual StatusCode	initialize () override
	Initialize.
virtual StatusCode	finalize () override
	Finalize.
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 Types
enum	ErrorWords { TIMEOUT_ERR =(1<<11) , L1_ERR =(1<<10) , BCID_ERR =(1<<9) , PREAMBLE_ERR =(1<<12) , FORMATTER_ERR =12 , TRAILER_ERR =(1<<12) , NULL_HEADER_ERR =0 , HEADER_TRAILER_ERR =(1<<11) , TRAILER_OVFLW_ERR =(1<<10) , ABCD_ERR =0 , RAWDATA_ERR =(3<<13) , NULL_TRAILER_ERR =0 }
	Definitions of enum error words to be retrieved from SCT_ByteStreamErrorSvc in fillROD(...) method. More...

Private Member Functions
void	encodeData (const std::vector< int > &vecTimeBins, std::vector< uint16_t > &vec16Words, const SCT_RDORawData *rdo, const int &groupSize, const int &strip) const
	Method to encode RDO data to vector of 16 bin words.
void	packFragments (std::vector< uint16_t > &vec16Words, std::vector< uint32_t > &vec32Words) const
	Method to pack vector of 16 bit words intto a vector of 32 bit words.
uint32_t	set32Bits (const unsigned short int arr16Words, const unsigned short int position, const unsigned short int &numWords) const
	@breif Method to set pairs of 16 bit words to a 32 bit word.
int	side (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
	Get the online Identifier from the RDO.
int	getRODLink (const SCT_RDORawData *rdo) const
	Get the ROD link number info in the RDO header data.
uint16_t	getHeaderUsingRDO (const SCT_RDORawData *rdo) const
	Get the 16-bit word for a header for a hit.
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.
uint16_t	getTrailer (const int &errorWord) const
	Get the 16-bit word for a trailer, with or without ByteStream errors.
void	addHeadersWithErrors (const uint32_t &robID, const std::set< IdentifierHash > *errors, const ErrorWords &errType, std::vector< uint16_t > &vec16Data) const
	Add header with errors for ROB to the vector of 16 bit words.
void	addTrailersWithErrors (const uint32_t &robID, const std::set< IdentifierHash > *errors, const ErrorWords &errType, std::vector< uint16_t > &vec16Data) const
	Add trailers with errors for ROB to the vector of 16 bit words.
void	addSpecificErrors (const uint32_t &robID, const std::set< IdentifierHash > *errors, const ErrorWords &errType, std::vector< uint16_t > &vec16Data) const
	Add specific errors for ROB to the vector of 16 bit words.

Private Attributes
ToolHandle< ISCT_ByteStreamErrorsTool >	m_bsErrTool
	Tool that keeps track of modules that give rise to errors in the bytestream.
ToolHandle< ISCT_CablingTool >	m_cabling
	Providing mappings of online and offline identifiers and also serial numbers.
const SCT_ID *	m_sctID {nullptr}
	Identifier helper class for the SCT subdetector that creates compact Identifier objects and IdentifierHash or hash IDs.
BooleanProperty	m_condensed
	Boolean used to determine if fillROD(...) should use Condensed or Expanded mode when decoding.
std::set< Identifier >	m_swapModuleID {}
	Swap Module identifier, set by SCTRawContByteStreamTool.

Detailed Description

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

This class inherits from AthAlgTool and ISCT_RodEncoder.

Note from Jan 09: Make SCT_RodEncoder an AlgTool again, of which there is one instance per job, rather than the lightweight class of which there was one instance per ROD. This change is motivated by the changes to write ByteStream errors back into the bytestream, as we don't want to access the ByteStreamErrorsSvc 90 times per event if we can avoid it..

Definition at line 40 of file SCT_RodEncoder.h.

Member Enumeration Documentation

◆ ErrorWords

enum SCT_RodEncoder::ErrorWords

private

Definitions of enum error words to be retrieved from SCT_ByteStreamErrorSvc in fillROD(...) method.

Enumerator
TIMEOUT_ERR
L1_ERR
BCID_ERR
PREAMBLE_ERR
FORMATTER_ERR
TRAILER_ERR
NULL_HEADER_ERR
HEADER_TRAILER_ERR
TRAILER_OVFLW_ERR
ABCD_ERR
RAWDATA_ERR
NULL_TRAILER_ERR

Definition at line 73 of file SCT_RodEncoder.h.

                 {TIMEOUT_ERR=(1<<11),
                  L1_ERR=(1<<10),
                  BCID_ERR=(1<<9),
                  PREAMBLE_ERR=(1<<12),
                  FORMATTER_ERR=12,
                  TRAILER_ERR=(1<<12),
                  NULL_HEADER_ERR=0,
                  HEADER_TRAILER_ERR=(1<<11),
                  TRAILER_OVFLW_ERR=(1<<10),
                  ABCD_ERR=0,
                  RAWDATA_ERR=(3<<13),
                  NULL_TRAILER_ERR=0};

Constructor & Destructor Documentation

◆ SCT_RodEncoder()

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

Constructor.

Definition at line 45 of file SCT_RodEncoder.cxx.

                                                         : 
  base_class(type, name, parent)
{
}

◆ ~SCT_RodEncoder()

virtual SCT_RodEncoder::~SCT_RodEncoder ( )

virtualdefault

Destructor.

Member Function Documentation

◆ addHeadersWithErrors()

void SCT_RodEncoder::addHeadersWithErrors	(	const uint32_t &	robID,
		const std::set< IdentifierHash > *	errors,
		const ErrorWords &	errType,
		std::vector< uint16_t > &	vec16Data ) const

private

Add header with errors for ROB to the vector of 16 bit words.

Definition at line 415 of file SCT_RodEncoder.cxx.

{
  for (const IdentifierHash& linkHash: *errors) {
    const uint32_t errROBID{m_cabling->getRobIdFromHash(linkHash)};
    if (errROBID == robID) {
      const uint16_t header{getHeaderUsingHash(linkHash, errType)};
      vec16Data.push_back(header);
      const uint16_t trailer{getTrailer(NULL_TRAILER_ERR)};
      vec16Data.push_back(trailer);
    }
  }
} 

◆ addSpecificErrors()

void SCT_RodEncoder::addSpecificErrors	(	const uint32_t &	robID,
		const std::set< IdentifierHash > *	errors,
		const ErrorWords &	errType,
		std::vector< uint16_t > &	vec16Data ) const

private

Add specific errors for ROB to the vector of 16 bit words.

Definition at line 444 of file SCT_RodEncoder.cxx.

{
  for (const IdentifierHash& linkHash: *errors) {
    const uint32_t errROBID{m_cabling->getRobIdFromHash(linkHash)};
    if (errROBID == robID) {
      const uint16_t header{getHeaderUsingHash(linkHash, NULL_HEADER_ERR)};
      const uint16_t trailer{getTrailer(NULL_TRAILER_ERR)};
      vec16Data.push_back(header);
      vec16Data.push_back(errType);
      vec16Data.push_back(trailer);
    }
  }
}

◆ addTrailersWithErrors()

void SCT_RodEncoder::addTrailersWithErrors	(	const uint32_t &	robID,
		const std::set< IdentifierHash > *	errors,
		const ErrorWords &	errType,
		std::vector< uint16_t > &	vec16Data ) const

private

Add trailers with errors for ROB to the vector of 16 bit words.

Definition at line 430 of file SCT_RodEncoder.cxx.

{
  for (const IdentifierHash& linkHash: *errors) {
    const uint32_t errROBID{m_cabling->getRobIdFromHash(linkHash)};
    if (errROBID == robID) {
      const uint16_t header{getHeaderUsingHash(linkHash, NULL_HEADER_ERR)};
      const uint16_t trailer{getTrailer(errType)};
      vec16Data.push_back(header);
      vec16Data.push_back(trailer);
    }
  }
}

◆ encodeData()

void SCT_RodEncoder::encodeData	(	const std::vector< int > &	vecTimeBins,
		std::vector< uint16_t > &	vec16Words,
		const SCT_RDORawData *	rdo,
		const int &	groupSize,
		const int &	strip ) const

private

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 243 of file SCT_RodEncoder.cxx.

{
  const int encodedSide{side(rdo) << 14};
  
  const Identifier idColl{offlineID(rdo)};
  int tmpStrip{strip};
  if (m_swapModuleID.find(idColl) != m_swapModuleID.end()) { // Check if the strip has to be swapped (swap phi readout direction)
    tmpStrip= 767 - tmpStrip;
    tmpStrip= tmpStrip-(groupSize-1);
  }
  
  const int chipNum{((tmpStrip/128) & 0x7) << 11};
  const int clustBaseAddr{((tmpStrip-(chipNum*128)) & 0x7F) << 4};
 
  int timeBin{0};
  int firstHitErr{0 << 2};
  int secondHitErr{0 << 3};
  
  const SCT3_RawData* rdoCosmic{dynamic_cast<const SCT3_RawData*>(rdo)};
  if (rdoCosmic != nullptr) {
    timeBin = getTimeBin(rdoCosmic);
    firstHitErr = ((rdoCosmic)->FirstHitError()) << 2;
    secondHitErr = ((rdoCosmic)->SecondHitError()) << 3;
  }
  
  if (m_condensed.value()) { // Condensed mode
    if (groupSize == 1) { // For single hit
      const uint16_t hitCondSingle{static_cast<uint16_t>(0x8000 | encodedSide | chipNum | clustBaseAddr | firstHitErr)};
      vec16Words.push_back(hitCondSingle);
    } 
    else if (groupSize == 2) { //  For paired strip Hits
      const uint16_t hitCondPaired{static_cast<uint16_t>(0x8001 | encodedSide | chipNum | clustBaseAddr | secondHitErr | firstHitErr)};
      vec16Words.push_back(hitCondPaired);
    }    
  } // End of Condensed mode
  
  else { // Expanded mode
    const int numEven{static_cast<int>((vecTimeBins.size() - 1)/2)};
 
    // First hit
    const uint16_t hitExpFirst{static_cast<uint16_t>(0x8000 | encodedSide | chipNum | clustBaseAddr | timeBin)};
    vec16Words.push_back(hitExpFirst);
 
    // Even consecutive strips to the first one 1DDD 1st consec strip 1DDD 2nd consec strip
    for (int i{1}; i<=numEven; i++) {
      const uint16_t hitExpEven{static_cast<uint16_t>(0x8088 | ((vecTimeBins[(2*i-1)] & 0xF) << 4) | (vecTimeBins[2*i] & 0xF))};
      vec16Words.push_back(hitExpEven);
    }
    // Last bin of the Odd next hits
    if ((not vecTimeBins.empty()) and isEven(vecTimeBins.size())) {
      const uint16_t hitExpLast{static_cast<uint16_t>(0x8008 | (vecTimeBins[vecTimeBins.size()-1] & 0xF))};
      vec16Words.push_back(hitExpLast);
    }  
  } // End of Expanded mode
  
  return;
}

◆ fillROD()

void SCT_RodEncoder::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 91 of file SCT_RodEncoder.cxx.

{
  // Retrieve errors from SCT_ByteStreamErrorsSvc
  const EventContext& ctx{Gaudi::Hive::currentContext()};
  const std::set<IdentifierHash> timeOutErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::TimeOutError,ctx)};
  const std::set<IdentifierHash> lvl1IDErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::LVL1IDError,ctx)};
  const std::set<IdentifierHash> bcIDErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::BCIDError,ctx)};
  const std::set<IdentifierHash> preambleErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::PreambleError,ctx)};
  const std::set<IdentifierHash> formatterErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::FormatterError,ctx)};
  const std::set<IdentifierHash> trailerErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::TrailerError,ctx)};
  const std::set<IdentifierHash> headerTrailerErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::HeaderTrailerLimitError,ctx)};
  const std::set<IdentifierHash> trailerOverflowErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::TrailerOverflowError,ctx)};
  const std::set<IdentifierHash> abcdErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::ABCDError,ctx)};
  const std::set<IdentifierHash> rawErrors{m_bsErrTool->getErrorSet(SCT_ByteStreamErrors::RawError,ctx)};
 
  std::vector<uint16_t> vec16Data;
  
  // Loop over errors here - just add headers (w/ errors), trailers (w/errors), and raw and abcd errors
  addHeadersWithErrors(robID, &timeOutErrors, TIMEOUT_ERR, vec16Data);
  addHeadersWithErrors(robID, &lvl1IDErrors, L1_ERR, vec16Data);
  addHeadersWithErrors(robID, &bcIDErrors, BCID_ERR, vec16Data);
  addHeadersWithErrors(robID, &preambleErrors, PREAMBLE_ERR, vec16Data);
  addHeadersWithErrors(robID, &formatterErrors, FORMATTER_ERR, vec16Data);
  
  addTrailersWithErrors(robID, &trailerErrors, TRAILER_ERR, vec16Data);
  addTrailersWithErrors(robID, &headerTrailerErrors, HEADER_TRAILER_ERR, vec16Data);
  addTrailersWithErrors(robID, &trailerOverflowErrors, TRAILER_OVFLW_ERR, vec16Data);
  
  addSpecificErrors(robID, &abcdErrors, ABCD_ERR, vec16Data);
  addSpecificErrors(robID, &rawErrors, RAWDATA_ERR, vec16Data);
  
  std::vector<bool> vec_isDuplicated(vecRDOs.size(), false);
  
  // Loop over RDOs to check for duplicates and fill vec_isDuplicated vector
  for (unsigned int iRDO1{0}; iRDO1<vecRDOs.size(); iRDO1++) {
    const SCT_RDORawData* rdo1{vecRDOs.at(iRDO1)};
    if (rdo1 == nullptr) {
      ATH_MSG_ERROR("RDO pointer is nullptr. skipping this hit.");
      vec_isDuplicated.at(iRDO1) = true;
      continue;
    }
 
    // Check if there is another RDO with the same first strip
    for (unsigned int iRDO2{0}; iRDO2<iRDO1; iRDO2++) {
      const SCT_RDORawData* rdo2{vecRDOs.at(iRDO2)};
      if (vec_isDuplicated.at(iRDO2)) continue;
 
      if (rdo1->identify() == rdo2->identify()) {
        // Keep RDO with larger cluster size. If cluster sizes are the same, keep the first one.
        if (rdo1->getGroupSize() >= rdo2->getGroupSize()) {
          vec_isDuplicated.at(iRDO2) = true;
        } 
        else {
          vec_isDuplicated.at(iRDO1)  = true;
        }
        break;
      }
    }
  }
 
  std::vector<int> vecTimeBins;
  int strip{0};
  int timeBin{0};
  int groupSize{0};
 
  uint32_t lastHeader{0};
  bool firstInROD{true};
  uint16_t lastTrailer{0};
 
  // Loop over RDOs to decode to 16 bit words
  for (unsigned int iRDO{0}; iRDO<vecRDOs.size(); iRDO++) {
    const SCT_RDORawData* rdo{vecRDOs.at(iRDO)};
    if (vec_isDuplicated.at(iRDO)) continue;
 
    const uint16_t header{this->getHeaderUsingRDO(rdo)};
    if (header != lastHeader) {
      if (not firstInROD) {
        vec16Data.push_back(lastTrailer);
      }
      firstInROD = false;
      vec16Data.push_back(header);
      lastHeader = header;
      lastTrailer = getTrailer(0);
    }
    if (m_condensed.value()) { // Condensed mode
      strip = getStrip(rdo);
      groupSize = rdo->getGroupSize();
      if (groupSize == 1) { // For single hit
        const int constGroupSize{1};
        const int constStrip{strip};
        encodeData(vecTimeBins, vec16Data, rdo, constGroupSize, constStrip);
      }
      // Sim RDO could have groupe size > 1, then they are split 2 by 2 to built the condensed BS data.
      else { // Encoding in condensed BS paired data from groupe size > 1.
        const int chipFirst{strip/128};
        const int chipLast{(strip+groupSize-1)/128};
 
        for (int chip{chipFirst}; chip<=chipLast; chip++) {
          int tmpGroupSize = 0;
          if (chipFirst == chipLast) tmpGroupSize = groupSize; // In case of one chip
          else if (chip == chipLast) tmpGroupSize = strip+groupSize-chip*128; // In case of last chip
          else if (chip == chipFirst) tmpGroupSize = (chip+1)*128-strip; // In case of first chip
          else tmpGroupSize = 128; // In case of middle chip
          const int tmpStrip1{chip==chipFirst ? strip : 128*chip};
 
          const int numPairedRDO{tmpGroupSize/2};
          for (int i =0; i<numPairedRDO; i++) {
            const int constGroupSize{2};
            const int constStrip{tmpStrip1+ (2*i)};
            encodeData(vecTimeBins, vec16Data, rdo, constGroupSize, constStrip);
          } 
          if ((tmpGroupSize != 0) and isOdd(tmpGroupSize)) {// The last hit from a cluster with odd group size
            const int constGroupSize{1};
            const int constStrip{tmpStrip1+ (tmpGroupSize - 1)};
            encodeData(vecTimeBins, vec16Data, rdo, constGroupSize, constStrip);
          }  
        }
      }  
      
    } // End of Condensed mode
    
    else { // Expanded mode
      vecTimeBins.clear();
      const SCT_RDORawData* rdo{vecRDOs.at(iRDO)};
      strip = getStrip(rdo);
      timeBin = getTimeBin(rdo);
      groupSize = rdo->getGroupSize();
      
      for (int t{0}; t < groupSize; t++) {
        vecTimeBins.push_back(timeBin);
        strip++;
      }
      const int constStrip{getStrip(rdo)};
      const int constGroupSize{rdo->getGroupSize()};
      encodeData(vecTimeBins, vec16Data, rdo, constGroupSize, constStrip);
      
    }  // End of Expanded mode
  } // End of RDO decode loop
 
  if ((not firstInROD) and (lastTrailer != 0)) {
    vec16Data.push_back(lastTrailer);
  }
  
  // 16 bits TO 32 bits and pack into 32 bit vectors
  packFragments(vec16Data,vec32Data);
  
  return;
}

◆ finalize()

StatusCode SCT_RodEncoder::finalize ( )

overridevirtual

Finalize.

Definition at line 84 of file SCT_RodEncoder.cxx.

{
  return StatusCode::SUCCESS;
}

◆ getHeaderUsingHash()

uint16_t SCT_RodEncoder::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 400 of file SCT_RodEncoder.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 SCT_RodEncoder::getHeaderUsingRDO ( const SCT_RDORawData * rdo ) const

private

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

Definition at line 393 of file SCT_RodEncoder.cxx.

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

◆ getRODLink()

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

private

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

Definition at line 368 of file SCT_RodEncoder.cxx.

{
  return rodLinkFromOnlineID(onlineID(rdo));
}

◆ getStrip()

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

private

Get the strip number info from the RDO.

Definition at line 349 of file SCT_RodEncoder.cxx.

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

◆ getTimeBin()

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

private

Get the time bin info from the RDO.

Definition at line 383 of file SCT_RodEncoder.cxx.

{
  int timeBin{0};
  const SCT3_RawData* rdoCosmic{dynamic_cast<const SCT3_RawData*>(rdo)};
  if (rdoCosmic != nullptr) timeBin = rdoCosmic->getTimeBin();
  return timeBin;
}

◆ getTrailer()

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

private

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

Definition at line 407 of file SCT_RodEncoder.cxx.

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

◆ initialize()

StatusCode SCT_RodEncoder::initialize ( )

overridevirtual

Initialize.

Definition at line 53 of file SCT_RodEncoder.cxx.

{
  ATH_MSG_DEBUG("SCT_RodEncoder::initialize()");
  
  // Retrieve cabling tool
  ATH_CHECK(m_cabling.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_cabling);
 
  ATH_CHECK(detStore()->retrieve(m_sctID, "SCT_ID"));
  ATH_CHECK(m_bsErrTool.retrieve());
 
  // See if strip numbers go from 0 to 767 or vice versa for all the wafers.
  // swapPhiReadoutDirection will not change during a run.
  // Since this is access to SiDetectorElement during initialization,
  // condition object of SiDetectorElementCollection is not accessible.
  // SCT_DetectorManager has to be used.
  const InDetDD::SCT_DetectorManager* sctDetManager{nullptr};
  ATH_CHECK(detStore()->retrieve(sctDetManager, "SCT"));
 
  const InDetDD::SiDetectorElementCollection* sctDetElementColl{sctDetManager->getDetectorElementCollection()};
  for (const InDetDD::SiDetectorElement* sctDetElement : *sctDetElementColl) {
    if (sctDetElement->swapPhiReadoutDirection()) {
      m_swapModuleID.insert(sctDetElement->identify());
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ offlineID()

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

private

Get the offline Identifier from the RDO.

Definition at line 355 of file SCT_RodEncoder.cxx.

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

◆ onlineID()

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

private

Get the online Identifier from the RDO.

Definition at line 361 of file SCT_RodEncoder.cxx.

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

◆ packFragments()

void SCT_RodEncoder::packFragments	(	std::vector< uint16_t > &	vec16Words,
		std::vector< uint32_t > &	vec32Words ) const

private

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

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

Parameters

vec16Words	Vector containing 16 bit words.
vec32Words	Vector for 32 bit words to be packed.

Definition at line 304 of file SCT_RodEncoder.cxx.

{
  int num16Words{static_cast<int>(vec16Words.size())};
  if (isOdd(num16Words)) {
    // Just add an additional 16bit words to make even size v16 to in the 32 bits word 0x40004000
    vec16Words.push_back(0x4000);
    num16Words++;
  }
  // Now merge 2 consecutive 16 bit words in 32 bit words
  const unsigned short int numWords{2};
  const unsigned short int position[numWords]{0, 16};
  unsigned short int arr16Words[numWords]{0, 0};
  for (int i{0}; i<num16Words; i += numWords) {
    arr16Words[i%numWords]     = vec16Words[i+1];
    arr16Words[(i+1)%numWords] = vec16Words[i];
    const uint32_t uint32Word{set32Bits(arr16Words, position, numWords)};
    vec32Words.push_back(uint32Word);
#ifdef SCT_DEBUG
    ATH_MSG_INFO("SCT encoder -> PackFragments: Output rod 0x"<<std::hex<<uint32Word<<std::dec);
#endif
  }
  
  return;
}

◆ set32Bits()

uint32_t SCT_RodEncoder::set32Bits	(	const unsigned short int *	arr16Words,
		const unsigned short int *	position,
		const unsigned short int &	numWords ) const

private

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

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

Parameters

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

Definition at line 332 of file SCT_RodEncoder.cxx.

{
  uint32_t uint32Word{0};
  uint32_t pos{0};
  uint32_t uint16Word{0};
  for (uint16_t i{0}; i<numWords; i++) {
    uint16Word = static_cast<uint32_t>(*(arr16Words+i));
    pos = static_cast<uint32_t>(*(position+i));
    uint32Word |= (uint16Word<<pos);
  } 
  return uint32Word;
}

◆ side()

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

private

Get the side info from the RDO.

Definition at line 373 of file SCT_RodEncoder.cxx.

{
  const Identifier rdoID{rdo->identify()};
  int sctSide{m_sctID->side(rdoID)};
  // see if we need to swap sides due to cabling weirdness
  const int linkNum{getRODLink(rdo) & 0xF};
  if (swappedCable(sctSide,linkNum)) sctSide = 1-sctSide;
  return sctSide;
}

Member Data Documentation

◆ m_bsErrTool

ToolHandle<ISCT_ByteStreamErrorsTool> SCT_RodEncoder::m_bsErrTool

private

Initial value:

{this, 
                                                    "SCT_ByteStreamErrorsTool", 
                                                    "SCT_ByteStreamErrorsTool", 
                                                    "Tool to retrieve SCT ByteStream Errors"}

Tool that keeps track of modules that give rise to errors in the bytestream.

Definition at line 163 of file SCT_RodEncoder.h.

                                                   {this, 
                                                    "SCT_ByteStreamErrorsTool", 
                                                    "SCT_ByteStreamErrorsTool", 
                                                    "Tool to retrieve SCT ByteStream Errors"};

◆ m_cabling

ToolHandle<ISCT_CablingTool> SCT_RodEncoder::m_cabling

private

Initial value:

{this, 
                                         "SCT_CablingTool", 
                                         "SCT_CablingTool", 
                                         "Tool to retrieve SCT Cabling"}

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

Definition at line 169 of file SCT_RodEncoder.h.

                                        {this, 
                                         "SCT_CablingTool", 
                                         "SCT_CablingTool", 
                                         "Tool to retrieve SCT Cabling"};

◆ m_condensed

BooleanProperty SCT_RodEncoder::m_condensed

private

Initial value:

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

Boolean used to determine if fillROD(...) should use Condensed or Expanded mode when decoding.

Definition at line 179 of file SCT_RodEncoder.h.

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

◆ m_sctID

const SCT_ID* SCT_RodEncoder::m_sctID {nullptr}

private

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

Also allows decoding of these IDs.

Definition at line 176 of file SCT_RodEncoder.h.

176{nullptr};

◆ m_swapModuleID

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

private

Swap Module identifier, set by SCTRawContByteStreamTool.

Definition at line 185 of file SCT_RodEncoder.h.

185{};

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ErrorWords

Constructor & Destructor Documentation

◆ SCT_RodEncoder()

◆ ~SCT_RodEncoder()

Member Function Documentation

◆ addHeadersWithErrors()

◆ addSpecificErrors()

◆ addTrailersWithErrors()

◆ encodeData()

◆ fillROD()

◆ finalize()

◆ getHeaderUsingHash()

◆ getHeaderUsingRDO()

◆ getRODLink()

◆ getStrip()

◆ getTimeBin()

◆ getTrailer()

◆ initialize()

◆ offlineID()

◆ onlineID()

◆ packFragments()

◆ set32Bits()

◆ side()

Member Data Documentation

◆ m_bsErrTool

◆ m_cabling

◆ m_condensed

◆ m_sctID

◆ m_swapModuleID