SCT_RodDecoder Class Reference

Athena Algorithm Tool to decode the SCT binary format to create RDOs and inserts them to the collection. More...

#include <SCT_RodDecoder.h>

Inheritance diagram for SCT_RodDecoder:

Collaboration diagram for SCT_RodDecoder:

Classes
struct	CacheHelper
	Temp object to help with trigger caching. More...
struct	SharedData
	Struct to hold data shared in methods used in fillCollection method. More...

Public Member Functions
	SCT_RodDecoder (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~SCT_RodDecoder ()=default
	Destructor.
virtual StatusCode	initialize () override
	Initialize.
virtual StatusCode	finalize () override
	Finalize.
virtual StatusCode	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment &robFrag, SCT_RDO_Container &rdoIDCont, IDCInDetBSErrContainer &errs, DataPool< SCT3_RawData > *dataItemsPool, const EventContext &ctx, const std::vector< IdentifierHash > *vecHash=nullptr) const override
	Fill SCT RDO Collection with decoded ROB data.

Private Types
enum	SCT_DecoderNumbers { N_SIDES = 2 , N_CHIPS_PER_SIDE = 6 , N_STRIPS_PER_CHIP = 128 , N_STRIPS_PER_SIDE = N_CHIPS_PER_SIDE*N_STRIPS_PER_CHIP }
	Define frequently used magic numbers. More...

Private Member Functions
int	makeRDO (const bool isOld, SharedData &data, CacheHelper &cache, DataPool< SCT3_RawData > *dataItemsPool) const
	Builds RawData RDO and adds to RDO container.
StatusCode	addRODError (uint32_t rodID, SCT_ByteStreamErrors::ErrorType error, SCT_RodDecoderErrorsHelper &errs, const EventContext &ctx, const std::unordered_set< IdentifierHash > *foundHashes=nullptr) const
	Add an error for each wafer in the problematic ROD.
StatusCode	addSingleError (const IdentifierHash &hashID, SCT_ByteStreamErrors::ErrorType error, SCT_RodDecoderErrorsHelper &errs, const EventContext &ctx) const
	Add single eror.
StatusCode	setFirstTempMaskedChip (const IdentifierHash &hashID, unsigned int firstTempMaskedChip, SCT_RodDecoderErrorsHelper &errs, const EventContext &ctx) const
	Set first temporarily masked chip information from byte stream trailer.
StatusCode	processHeader (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RDO_Container &rdoIDCont, DataPool< SCT3_RawData > *dataItemsPool, CacheHelper &cache, SCT_RodDecoderErrorsHelper &errs, bool &hasError, bool &breakNow, const EventContext &ctx) const
	Process header word.
StatusCode	processSuperCondensedHit (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RDO_Container &rdoIDCont, DataPool< SCT3_RawData > *dataItemsPool, CacheHelper &cache, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process hit word in Super-Condensed mode.
StatusCode	processCondensedHit (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RDO_Container &rdoIDCont, DataPool< SCT3_RawData > *dataItemsPool, CacheHelper &cache, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process hit word in Condensed mode.
StatusCode	processExpandedHit (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RDO_Container &rdoIDCont, DataPool< SCT3_RawData > *dataItemsPool, CacheHelper &cache, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process hit word in Expanded mode.
StatusCode	processABCDError (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process ABCD error.
StatusCode	processRawData (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process raw data word.
StatusCode	processTrailer (const uint16_t inData, const uint32_t robID, SharedData &data, SCT_RodDecoderErrorsHelper &errs, bool &hasError, const EventContext &ctx) const
	Process trailer word.

Private Attributes
const SCT_ID *	m_sctID {nullptr}
	Identifier helper class for the SCT subdetector that creates compact Identifier objects and IdentifierHash or hash IDs.
IdContext	m_contextSCT
	"Context" of an expanded identifier (ExpandedIdentifier) for compact or hash versions (Identifier32 or IdentifierHash)
ToolHandle< ISCT_CablingTool >	m_cabling
	Providing mappings of online and offline identifiers and also serial numbers.
ToolHandle< ISCT_ConfigurationConditionsTool >	m_configTool
	Service that keeps track of configuration conditions.
std::atomic_uint	m_singleCondHitNumber {0}
	Total number of single strips with hit decoded in condensed mode.
std::atomic_uint	m_pairedCondHitNumber {0}
	Total number of paired strips with hit decoded in condensed mode.
std::atomic_uint	m_firstExpHitNumber {0}
	Total number of first strips with hit decoded in expanded mode.
std::atomic_uint	m_evenExpHitNumber {0}
	Total number of consecutive paired strips with hit decoded in expanded mode.
std::atomic_uint	m_lastExpHitNumber {0}
	Total number of last consecutive strips with hit decoded in expanded mode.
std::atomic_uint	m_headNumber {0}
	Total number of decoded header data.
std::atomic_uint	m_trailerNumber {0}
	Total number of decoded trailer data.
std::atomic_uint	m_headErrorBCID {0}
	Total number of BCID errors in the header data.
std::atomic_uint	m_headErrorLvl1ID {0}
	Total number of Lvl1ID errors in the header data.
std::atomic_uint	m_headErrorTimeout {0}
	Total number of timeout errors in the header data.
std::atomic_uint	m_headErrorFormatter {0}
	Total number of formatter errors in the header data.
std::atomic_uint	m_headErrorPreamble {0}
	Total number of preamble errors in the header data.
std::atomic_uint	m_trailerErrorOverflow {0}
	Total number of overflow errors in the trailer data.
std::atomic_uint	m_trailerErrorLimit {0}
	Total number of header trailer limit errors in the trailer data.
std::atomic_uint	m_trailerErrorBit {0}
	Total number of trailer bit errors.
std::atomic_uint	m_configDataBit {0}
	Total number of configuration data for raw data.
std::atomic_uint	m_flagErrorBit {0}
	Total number of flag error data.
std::atomic_uint	m_condHit1Error {0}
	Total number of first hit data errors.
std::atomic_uint	m_condHit2Error {0}
	Total number second hit data errors.
std::atomic_uint	m_chipNumberError {0}
	Total number of chip number errors.
std::atomic_uint	m_unknownDataFormat {0}
	Total number of unknown data formats.
std::atomic_uint	m_nHits {0}
	Total number of SCT hits in ByteStream.
std::atomic_uint	m_nRDOs {0}
	Total number of SCT RDOs created.
std::atomic_uint	m_maskedLinkNumber {0}
	Total number of masked links in the header data.
std::atomic_uint	m_maskedRODNumber {0}
	Total number of masked RDOs.
std::atomic_uint	m_rodClockErrorNumber {0}
	Total number of ROD clock errors.
std::atomic_uint	m_truncatedRODNumber {0}
	Total number of truncated ROBFragments.
std::atomic_uint	m_numMissingLinkHeader {0}
	Total number of missing link headers.
std::vector< bool >	m_swapPhiReadoutDirection {}
	Swap phi readout direction.

Detailed Description

Athena Algorithm Tool to decode the SCT binary format to create RDOs and inserts them to the collection.

This tool is used by the SCTRawCollByteStreamTool.

Definition at line 76 of file SCT_RodDecoder.h.

Member Enumeration Documentation

SCT_DecoderNumbers

enum SCT_RodDecoder::SCT_DecoderNumbers

private

Define frequently used magic numbers.

Enumerator
N_SIDES
N_CHIPS_PER_SIDE
N_STRIPS_PER_CHIP
N_STRIPS_PER_SIDE

Definition at line 122 of file SCT_RodDecoder.h.

                          { N_SIDES = 2,
                            N_CHIPS_PER_SIDE = 6,
                            N_STRIPS_PER_CHIP = 128,
                            N_STRIPS_PER_SIDE = N_CHIPS_PER_SIDE*N_STRIPS_PER_CHIP,
  };

Constructor & Destructor Documentation

SCT_RodDecoder()

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

Constructor.

Definition at line 20 of file SCT_RodDecoder.cxx.

                                                         :
  base_class(type, name, parent)
{
}

~SCT_RodDecoder()

virtual SCT_RodDecoder::~SCT_RodDecoder ( )

virtualdefault

Destructor.

Member Function Documentation

addRODError()

StatusCode SCT_RodDecoder::addRODError ( uint32_t rodID, SCT_ByteStreamErrors::ErrorType error, SCT_RodDecoderErrorsHelper & errs, const EventContext & ctx, const std::unordered_set< IdentifierHash > * foundHashes = nullptr ) const

private

Add an error for each wafer in the problematic ROD.

Parameters

rodID	Identifer of ROD.
errorType	Error type info.
errs	Byte stream error container.
ctx	EventContext
foundHashes	FE-links whose headers are found. Used only for MissingLinkHeaderError.

Definition at line 430 of file SCT_RodDecoder.cxx.

{
  std::vector<IdentifierHash> hashIDs;
  m_cabling->getHashesForRod(hashIDs, rodID);
  for (const IdentifierHash& hash: hashIDs) {
    // MissingLinkHeaderError is filled in only FE-links of the ROD whose headers are not found.
    // We cannot know which FE-link does not have header. However, we should not add the error to found ones.
    if ((error==SCT_ByteStreamErrors::MissingLinkHeaderError) and
        foundHashes and foundHashes->count(hash)) {
      continue;
    }
 
    // Skip disabled modules
    if(!m_configTool->isGood(hash, ctx)) {
      continue;
    }
 
    // Skip bad links
    const auto & [link0Good, link1Good] = m_configTool->badLinks(hash, ctx);
    int side{m_sctID->side(m_sctID->wafer_id(hash))};
    const bool result{side==0 ? not link0Good : not link1Good};
    if (result) continue;
 
    ATH_CHECK(addSingleError(hash, error, errs, ctx));
  }
  return StatusCode::SUCCESS;
}

addSingleError()

StatusCode SCT_RodDecoder::addSingleError ( const IdentifierHash & hashID, SCT_ByteStreamErrors::ErrorType error, SCT_RodDecoderErrorsHelper & errs, const EventContext & ctx ) const

private

Add single eror.

Parameters

hashID	Identifier for hash.
bsErrorType	Byte Stream error type info.
errs	Byte stream error container.
ctx	EventContext

error in a module using RX redundancy - add an error for the other link as well!! However, ABCDError_Chip0-ABCDError_Chip5 and TempMaskedChip0-TempMaskedChip5 are not common for two links.

Definition at line 463 of file SCT_RodDecoder.cxx.

{
  if (not hashID.is_valid()) {
    ATH_MSG_INFO("addSingleError hashID " << hashID << " is invalid.");
    return StatusCode::SUCCESS;
  }
 
  errs.add(hashID, error);
 
  if ((error<SCT_ByteStreamErrors::ABCDError_Chip0 || error>SCT_ByteStreamErrors::ABCDError_Chip5) and
      (error<SCT_ByteStreamErrors::TempMaskedChip0 || error>SCT_ByteStreamErrors::TempMaskedChip5)) {
    std::pair<bool, bool> badLinks{m_configTool->badLinks(hashID, ctx)};
    int side{m_sctID->side(m_sctID->wafer_id(hashID))};
    bool result{(side==0 ? badLinks.first : badLinks.second) and (badLinks.first xor badLinks.second)};
    if (result) {
      IdentifierHash otherSide;
      m_sctID->get_other_side(hashID, otherSide);
      errs.add(otherSide, error);
      ATH_MSG_DEBUG("Adding error to side " << 1-side << " for module with RX redundancy " << otherSide);
    }
  }
 
  return StatusCode::SUCCESS;
}

fillCollection()

StatusCode SCT_RodDecoder::fillCollection ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment & robFrag, SCT_RDO_Container & rdoIDCont, IDCInDetBSErrContainer & errs, DataPool< SCT3_RawData > * dataItemsPool, const EventContext & ctx, const std::vector< IdentifierHash > * vecHash = nullptr ) const

overridevirtual

Fill SCT RDO Collection with decoded ROB data.

Decode the rob data fragment and fill the collection SCT_RDO_Collection with the RDO built by the makeRDO(..) method. rdoIdc, and errs are updated based on robFrag and vecHash.

Parameters

robFrag	ROB fragment.
rdoIDCont	RDO ID Container to be filled.
errs	Byte stream error container.
vecHash	Vector of hashes.

Unknown

Definition at line 167 of file SCT_RodDecoder.cxx.

{
  SCT_RodDecoderErrorsHelper errs{errorsIDC}; // on destruction will fill the IDC
 
  const uint32_t robID{robFrag.rod_source_id()};
 
  // Determine whether this data was generated using the ROD simulator
  const uint32_t rodDataType{robFrag.rod_detev_type()};
  const bool rodSimulatedData{static_cast<bool>((rodDataType >> 20) & 0x1)};
  if (rodSimulatedData) ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::RODSimulatedData, errs, ctx));
 
  // Look for the bit that denotes "Super-condensed" mode
  const bool superCondensedMode{static_cast<bool>((rodDataType >> 21) & 0x1)};
 
  StatusCode sc{StatusCode::SUCCESS};
 
  // Look at ROB status word
  if (robFrag.nstatus()!=0) {
    const uint32_t* robStatus;
    robFrag.status(robStatus);
    if ((*robStatus)!=0) {
      ATH_MSG_DEBUG("ROB status word for robID " << std::hex << robID
                    << " is non-zero " << (*robStatus) << std::dec);
      // First store generic "ROBFragmentError" error type.
      ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::ROBFragmentError, errs, ctx));
      sc = StatusCode::RECOVERABLE;
      // Now look for specific problems, e.g. truncated or masked-off RODs
      if (((*robStatus) >> 27) & 0x1) {
        ATH_MSG_DEBUG("ROB status word for robID " << std::hex << robID
                      << std::dec << " indicates data truncation.");
        ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::TruncatedROD, errs, ctx));
        m_truncatedRODNumber++;
        return sc;
      }
      if ((((*robStatus) >> 29) & 0x1) or (((*robStatus) >> 31) & 0x1)) {
        ATH_MSG_DEBUG("ROB status word for robID " << std::hex << robID
                      << std::dec << " indicates resource was masked off.");
        ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::MaskedROD, errs, ctx));
        m_maskedRODNumber++;
        return sc;
      }
    }
  }
 
  // Look at ROD status words
  OFFLINE_FRAGMENTS_NAMESPACE::PointerType vecRODStatus;
  const long unsigned int vecRODStatusSize{robFrag.rod_nstatus()};
 
  robFrag.rod_status(vecRODStatus);
  for (long unsigned int i{0}; i<vecRODStatusSize; i++) {
    const uint32_t statusWord{vecRODStatus[i]};
    // Check for clock errors in second ROD status word
    if (i==1) {
      const int timClockError{static_cast<int>((statusWord >> 16) & 0x1)};
      const int bocClockError{static_cast<int>((statusWord >> 17) & 0x1)};
      if (timClockError or bocClockError) {
        ATH_MSG_DEBUG(" Clock error in ROD status word: " << timClockError << " " << bocClockError);
        ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::RODClockError, errs, ctx));
        m_rodClockErrorNumber++;
        sc=StatusCode::RECOVERABLE;
      }
      // Look at bits 20-23 for DCS HV
      // const int hvBits{static_cast<int>((statusWord >> 20) & 0xF)};
      // const bool hvOn{hvBits==0xF};
    }
  }
 
  SharedData data;
  data.reset();
 
  CacheHelper cache; // For the trigger
  cache.vecHash = vecHash;
 
  OFFLINE_FRAGMENTS_NAMESPACE::PointerType vecROBData;
  const unsigned long int vecROBDataSize{robFrag.rod_ndata()};
  if (vecROBDataSize >   robFrag.payload_size_word()) {
     ATH_MSG_WARNING("The ROB data does not seem to fit in the payload. Rejecting fragment (ndata size  " << vecROBDataSize << " !< payload size " << robFrag.payload_size_word()
                     << " header size: " <<  robFrag.rod_header_size_word()
                     << " trailer size: " << robFrag.rod_trailer_size_word()
                     << " fragment size: " << robFrag.rod_fragment_size_word()
                     << ")");
     return StatusCode::RECOVERABLE;
  }
  robFrag.rod_data(vecROBData);
 
  // Loop over header, hit element, flagged ABCD error, raw data, trailer words
  for (unsigned long int i{0}; i<vecROBDataSize; i++) {
    // The data is 16-bits wide packed to a 32-bit word (rob_it1). So we unpack it here.
    uint16_t data16[2];
    data16[0] = ((vecROBData[i] >> 16) & 0xFFFF);
    data16[1] = ( vecROBData[i]        & 0xFFFF);
 
    for (int n{0}; n<2; n++) {
      bool hasError{false};
      if (((data16[n]>>13) & 0x7) == 0x1) { // Header
        bool breakNow{false};
        ATH_CHECK(processHeader(data16[n], robID, data, rdoIDCont, dataItemsPool, cache, errs, hasError, breakNow, ctx));
        if (hasError) sc = StatusCode::RECOVERABLE;
        if (breakNow) break;
        continue;
      }
      else if (data16[n] & 0x8000) { // Hit element
        if (not data.foundHeader) {
          ATH_MSG_INFO(" Missing link header in ROD " << std::hex << robID << std::dec);
          data.foundMissingLinkHeaderError = true;
          m_numMissingLinkHeader++;
          sc = StatusCode::RECOVERABLE;
          continue;
        }
        m_nHits++;
        if (superCondensedMode) { // Super-condensed mode:
          ATH_CHECK(processSuperCondensedHit(data16[n], robID, data, rdoIDCont, dataItemsPool, cache, errs, hasError, ctx));
          if (hasError) sc = StatusCode::RECOVERABLE;
          continue;
        }
        else if (data.condensedMode) { // Condensed mode
          ATH_CHECK(processCondensedHit(data16[n], robID, data, rdoIDCont, dataItemsPool, cache, errs, hasError, ctx));
          if (hasError) sc = StatusCode::RECOVERABLE;
          continue;
        }
        else { // Expanded mode
          ATH_CHECK(processExpandedHit(data16[n], robID, data, rdoIDCont, dataItemsPool, cache, errs, hasError, ctx));
          if (hasError) sc = StatusCode::RECOVERABLE;
          continue;
        }
      }
      else if (((data16[n]>>13) & 0x7) == 0x0) { // FlaggedABCD error
        ATH_CHECK(processABCDError(data16[n], robID, data, errs, hasError, ctx));
        if (hasError) sc = StatusCode::RECOVERABLE;
        continue;
      }
      else if (((data16[n]>>13) & 0x7) == 0x3) { // Raw Data
        ATH_CHECK(processRawData(data16[n], robID, data, errs, hasError, ctx));
        if (hasError) sc = StatusCode::RECOVERABLE;
        continue;
      }
      else if (((data16[n]>>13) & 0x7) == 0x2) { // Trailer
        ATH_CHECK(processTrailer(data16[n], robID, data, errs, hasError, ctx));
        if (hasError) sc = StatusCode::RECOVERABLE;
        continue;
      }
      else { 
        ATH_MSG_DEBUG("Data word format unknown ");
        m_unknownDataFormat++;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
        sc = StatusCode::RECOVERABLE;
      }
    } // End of 16-bit word loop
  } // End of 32-bit word loop
 
  // Create the last RDO of the last link of the event
  if (data.isStripValid()) {
     if (not data.isSaved(false) and data.isOldStripValid()) {
        const int rdoMade{makeRDO(false, data, cache, dataItemsPool)};
        if (rdoMade == -1) {
           sc = StatusCode::RECOVERABLE;
           ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
        }
        else {
           data.setSaved(false, rdoMade);
        }
     }
  }
 
  // MissingLinkHeaderError is filled in only FE-lins of the ROD whose headers are not found.
  // We cannot know which FE-link does not have header. However, we should not add the error to found ones.
  if (data.foundMissingLinkHeaderError) {
    ATH_CHECK(addRODError(robID, SCT_ByteStreamErrors::MissingLinkHeaderError, errs, ctx, &(data.foundHashes)));
  }
 
  for (auto& [hash, rdoColl] : data.rdoCollMap) {
    if (rdoColl==nullptr) continue; // nullptr means the collection is already filled.
 
    if (rdoColl->empty()) { // Empty collection is not filled.
      rdoColl.reset();
      errs.removeIfEmpty(hash); // To get the same result as before. Not sure whether we need this.
      continue;
    }
 
    ATH_CHECK(data.writeHandleMap[hash].addOrDelete(std::move(rdoColl)));
  }
 
  if (sc.isFailure()) ATH_MSG_DEBUG("One or more ByteStream errors found ");
  return sc;
}

finalize()

StatusCode SCT_RodDecoder::finalize ( )

overridevirtual

Finalize.

Definition at line 62 of file SCT_RodDecoder.cxx.

{
  // Print out summaries of data and errors decoded
  ATH_MSG_INFO("SCT BytestreamCnv summary: " << m_headNumber  <<" link headers found");
  ATH_MSG_INFO("SCT BytestreamCnv summary: " << m_trailerNumber << " link trailers found");
 
  ATH_MSG_INFO("SCT decoding bytestream summary: "
               << m_singleCondHitNumber << " single strips with hit in condensed mode");
  ATH_MSG_INFO("SCT decoding bytestream summary: "
               << m_pairedCondHitNumber << " paired strips with hit in condensed mode");
  ATH_MSG_INFO("SCT decoding bytestream summary: "
               << m_firstExpHitNumber   << " first strips with hit in expanded mode");
  ATH_MSG_INFO("SCT decoding bytestream summary: "
               << m_evenExpHitNumber    << " consecutive paired strips with hit in expanded mode");
  ATH_MSG_INFO("SCT decoding bytestream summary: "
               << m_lastExpHitNumber    << " last consecutive strips with hit in expanded mode");
 
  if (m_headErrorBCID > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: header-> "
                 << m_headErrorLvl1ID    << " LVL1d errors found");
  }
  if (m_headErrorTimeout > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: header-> "
                 << m_headErrorTimeout   << " timeout errors found");
  }
  if (m_headErrorFormatter > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: header-> "
                 << m_headErrorFormatter << " formatter errors found");
  }
  if (m_headErrorPreamble > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: header-> "
                 << m_headErrorPreamble  << " preamble errors found");
  }
  if (m_maskedLinkNumber > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: header-> "
                 << m_maskedLinkNumber   << " masked links found");
  }
 
  if (m_trailerErrorOverflow > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: trailer-> "
                 << m_trailerErrorOverflow << " trailer data overflow errors found");
  }
  if (m_trailerErrorLimit > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: trailer-> "
                 << m_trailerErrorLimit    << " header trailer limit errors found");
  }
  if (m_trailerErrorBit > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: trailer-> "
                 << m_trailerErrorBit      << " trailer bit errors found");
  }
 
  if (m_configDataBit > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: raw Data-> "
                 << m_configDataBit << " raw data found: Config data mode");
  }
 
  if (m_flagErrorBit > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: flag-> "
                 << m_flagErrorBit << " module link flag bit errors found");
  }
 
  if (m_condHit1Error > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: hit-> "
                 << m_condHit1Error   << " 1st hit error found in condensed mode");
  }
  if (m_condHit2Error > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: hit-> "
                 << m_condHit2Error   << " 2nd hit error found in condensed mode");
  }
  if (m_chipNumberError > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: hit-> "
                 << m_chipNumberError << " Chip number > 5 error found");
  }
 
  if (m_unknownDataFormat > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: unknown data-> "
                 << m_unknownDataFormat << " Unknown data format found");
  }
 
  if (m_rodClockErrorNumber > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: ROD status word-> "
                 << m_rodClockErrorNumber << " ROD clock errors found");
  }
  if (m_maskedRODNumber > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: ROB status word-> "
                 << m_maskedRODNumber     << " masked RODs found");
  }
  if (m_truncatedRODNumber > 0) {
    ATH_MSG_INFO("SCT BytestreamCnv summary: ROB status word-> "
                 << m_truncatedRODNumber  << " truncated ROBFragments");
  }
 
  ATH_MSG_INFO("Number of SCT hits in ByteStream-> " << m_nHits);
  ATH_MSG_INFO("Number of SCT RDOs created->       " << m_nRDOs);
 
  if (m_numMissingLinkHeader > 0) ATH_MSG_WARNING("SCT Missing Link Headers found " << m_numMissingLinkHeader);
 
  ATH_CHECK(AlgTool::finalize());
  ATH_MSG_DEBUG("SCT_RodDecoder::finalize()");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode SCT_RodDecoder::initialize ( )

overridevirtual

Initialize.

Definition at line 28 of file SCT_RodDecoder.cxx.

{
  ATH_CHECK(AlgTool::initialize());
 
  // Retrieve cabling tool
  ATH_CHECK(m_cabling.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_cabling);
 
  ATH_CHECK(detStore()->retrieve(m_sctID,"SCT_ID"));
  m_contextSCT = m_sctID->wafer_context();
  m_swapPhiReadoutDirection.resize(m_sctID->wafer_hash_max(), false);
 
  ATH_CHECK(m_configTool.retrieve());
 
  // See if strip numbers go from 0 to N_STRIPS_PER_SIDE-1(=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* element: *sctDetElementColl) {
    if (element->swapPhiReadoutDirection()) {
      m_swapPhiReadoutDirection[element->identifyHash()] = true;
    }
  }
 
  return StatusCode::SUCCESS;
}

makeRDO()

int SCT_RodDecoder::makeRDO ( const bool isOld, SharedData & data, CacheHelper & cache, DataPool< SCT3_RawData > * dataItemsPool ) const

private

Builds RawData RDO and adds to RDO container.

Method that builds the RawData RDO and add it to the collection rdoIdc and cache are updated based on other arguments.

Returns

Method has 3 possible return values: 1 if RDO was successfully created 0 if collection was deliberately skipped (for trigger) -1 if there was an error in the decoding - will be passed on as StatusCode::RECOVERABLE by fillCollection()

Parameters

isOld	if true use data.oldStrip, otherwise use data.strip.
data	Struct to hold data shared in methods used in fillCollection method
cache	Cache.

Definition at line 360 of file SCT_RodDecoder.cxx.

{
  // If the link is already decoded, RDO will not be created.
  SCT_RDO_Collection* rdoColl{data.rdoCollMap[data.linkIDHash].get()};
  if (rdoColl==nullptr) return 0;
 
  int strip{isOld ? data.oldStrip : data.strip};
  if (((strip & 0x7F) + (data.groupSize-1) >= N_STRIPS_PER_CHIP) or (strip<0) or (strip>=N_STRIPS_PER_SIDE)) {
    ATH_MSG_DEBUG("Cluster with " << data.groupSize << " strips, starting at strip " << (strip & 0x7F) << " in Chip" << (strip / N_STRIPS_PER_SIDE) << " Side " << data.side <<", (old side, old strip) = (" << data.oldSide << ", " << data.oldStrip << ")"
          << " in collection " << data.linkIDHash << " (= " << m_cabling->getSerialNumberFromHash(data.linkIDHash) << ")  out of range. Will not make RDO");
    return -1;
  }
 
  // This option is for the trigger, if there is a vecHash* given, test it!
  if (cache.vecHash) {
    if (data.linkIDHash == cache.skipHash) {
      ATH_MSG_VERBOSE("Collection for Hash not to be decoded, skip");
      return 0;
    }
    else if (data.linkIDHash != cache.lastHash) {
      cache.lastHash = data.linkIDHash;
      // Maybe the new hash is not in the list, so test it
      std::vector<IdentifierHash>::const_iterator hashIDIterator{find(cache.vecHash->begin(),
                                                                      cache.vecHash->end(),
                                                                      data.linkIDHash)};
      if (hashIDIterator == cache.vecHash->end()) {
        ATH_MSG_VERBOSE("Collection for Hash not to be decoded, skip");
        // Remember this one, so that we do not find(...) forever
        cache.skipHash = data.linkIDHash;
        return 0;
      }
    }
  }
 
  // See if strips go from 0 to N_STRIPS_PER_SIDE-1(=767) or vice versa
  if (m_swapPhiReadoutDirection[data.linkIDHash]) {
    strip = N_STRIPS_PER_SIDE-1 - strip;
    strip = strip-(data.groupSize-1);
  }
 
  // Get identifier from the hash, this is not nice
  const Identifier digitID{m_sctID->strip_id(data.collID, strip)};
  if (not m_sctID->is_sct(digitID)) {
    ATH_MSG_WARNING("Cluster with invalid Identifier. Will not make RDO");
    return -1;
  }
 
  const unsigned int rawDataWord{static_cast<unsigned int>(data.groupSize | (strip << 11) | (data.timeBin <<22) | (data.errors << 25))};
 
  ATH_MSG_DEBUG("Output Raw Data " << std::hex << " Coll " << data.collID.getString()
                << ":-> " << m_sctID->print_to_string(digitID) << std::dec);
 
  // Now the Collection is there for sure. Create RDO and push it into Collection.
  m_nRDOs++;
 
  if(dataItemsPool){
    SCT3_RawData* sct_rdo = dataItemsPool->nextElementPtr();
    (*sct_rdo) = SCT3_RawData(digitID, rawDataWord, &(data.errorHit));
    rdoColl->push_back(sct_rdo);
  }else{
    rdoColl->push_back(std::make_unique<SCT3_RawData>(digitID, rawDataWord, &(data.errorHit)));
  }
  return 1;
}

processABCDError()

StatusCode SCT_RodDecoder::processABCDError ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process ABCD error.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 1114 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
 
  if (not data.foundHeader) {
    ATH_MSG_INFO(" Missing link header in ROD " << std::hex << robID << std::dec);
    data.foundMissingLinkHeaderError = true;
    m_numMissingLinkHeader++;
    hasError = true;
    return sc;
  }
 
  const int chip{(inData>>3) & 0xF};
  const int abcError{inData & 0x7};
  ATH_MSG_DEBUG(" xxx Flagged ABCD ERROR in chip " << chip
                << " Error code abcError " << abcError << " Link Number (or Stream) " << data.linkNumber);
  m_flagErrorBit++;
  // Error code of ABCD error should be 1, 2, 4 or 7.
  if (abcError!=0x1 and abcError!=0x2 and abcError!=0x4 and abcError!=0x7) {
    ATH_MSG_DEBUG("ABCD error has an invalid error code " << abcError
                  << " the 16-bit word is 0x" << std::hex << inData << std::dec
                  << " for hash " << data.linkIDHash);
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Invalid, errs, ctx));
  }
  else {
    // Chip is 4 bits. The highest bit 3 represents side. Chip 0-5 on side 0 and chip 8-13 on side 1.
    const unsigned int sideABCDError{static_cast<unsigned int>(chip/8)};
    if (data.linkIDHash.value()%2!=sideABCDError) {
      // If the sides from the ABCD error and online ID are different,
      // the module is expected to read side 0 via link 1 and side 1 and via link 0.
      // Hash Id is flipped.
      ATH_MSG_DEBUG("ABCD error and online ID have different side information for hash " << data.linkIDHash << ". "
                    << sideABCDError << " from ABCD error and " << data.linkIDHash.value()%2 << " from online ID");
      data.linkIDHash = (data.linkIDHash.value()/2)*2+sideABCDError;
      errs.noerror(data.linkIDHash);
    }
    // Chip should be 0-5 or 8-13.
    if (chip%8>=N_CHIPS_PER_SIDE) {
      ATH_MSG_DEBUG("ABCD error has an invalid chip 0x" << std::hex << chip << std::dec
                    << " the 16-bit word is 0x" << std::hex << inData << std::dec
                    << " for hash " << data.linkIDHash.value());
      ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Invalid, errs, ctx));
    }
    else {
      if (     abcError==0x1) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Error1, errs, ctx));
      else if (abcError==0x2) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Error2, errs, ctx));
      else if (abcError==0x4) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Error4, errs, ctx));
      else if (abcError==0x7) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Error7, errs, ctx));
      if (     chip%8==0) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip0, errs, ctx));
      else if (chip%8==1) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip1, errs, ctx));
      else if (chip%8==2) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip2, errs, ctx));
      else if (chip%8==3) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip3, errs, ctx));
      else if (chip%8==4) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip4, errs, ctx));
      else if (chip%8==5) ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError_Chip5, errs, ctx));
    }
  }
  ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ABCDError, errs, ctx));
  hasError = true;
 
  return sc;
}

processCondensedHit()

StatusCode SCT_RodDecoder::processCondensedHit ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RDO_Container & rdoIDCont, DataPool< SCT3_RawData > * dataItemsPool, CacheHelper & cache, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process hit word in Condensed mode.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
rdoIDCont	RDO ID Container to be filled.
cache	Cache.
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 868 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
  
  const int chip{(inData>>11) & 0x7};
  data.side = ((inData>>14) & 0x1);
  data.strip = chip*N_STRIPS_PER_CHIP + ((inData>>4) & 0x7F);
  data.timeBin = 0x2; // Assuming timeBin is 010 in condensed mode
  if (chip>=N_CHIPS_PER_SIDE) {
    ATH_MSG_DEBUG("    Hit condensed : xxx Chip number = " << chip << " >= " << N_CHIPS_PER_SIDE << " for hit "
                  << std::hex << inData);
    m_chipNumberError++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
    hasError = true;
    return sc;
  }
 
  // Search for redundancy only for the master chip
  bool secondSide{false};
  if ((data.side==1) and ((data.linkNumber%2)==0)) {
    if (((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) and (data.groupSize>0)) {
      // If it is a new cluster, make RDO with the previous cluster
      const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
      if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(true, rdoMade);
      }
      data.setOld();
    }
    data.linkNumber++;
    secondSide = true;
  }
  else if ((data.side==0) and ((data.linkNumber%2)!=0)) {
    if (((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) and (data.groupSize>0)) {
      // If it is a new cluster, make RDO with the previous cluster
      const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
      if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(true, rdoMade);
      }
      data.setOld();
    }
    data.linkNumber--;
    secondSide = true;
  }
  if (secondSide) {
    const uint32_t onlineID{(robID & 0xFFFFFF) | (data.linkNumber << 24)};
    data.setCollection(m_sctID, m_cabling->getHashFromOnlineId(onlineID, ctx), rdoIDCont, dataItemsPool, errs);
  }
 
  if (data.groupSize == 0)  {
    data.setOld(); // If it's the first condensed word
  }
 
  if (not (inData & 0x1)) { // 1-hit
    m_singleCondHitNumber++;
    if ((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) {
      // If it is a new cluster, make RDO with the previous cluster
      const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
      if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(true, rdoMade);
      }
      data.setOld();
    }
 
    if (inData & 0x4) { // Error in the hit
      ATH_MSG_DEBUG("    Hit condensed : xxx ERROR in 1-hit " << std::hex << inData);
      data.errorHit.push_back(data.groupSize);
      data.errors = (data.errors | 0x10);
      m_condHit1Error++;
      hasError = true;
    }
    data.groupSize = (data.groupSize>=2 ? data.groupSize : 1);
  }
  else { // 2-hits
    if (data.strip >= N_STRIPS_PER_SIDE) {
      ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      hasError = true;
 
      ATH_MSG_DEBUG("Condensed mode - strip number out of range");
 
      return sc;
    }
    m_pairedCondHitNumber++;
    if ((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) {
      // If it is a new cluster, make RDO with the previous cluster
      const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
      if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(true, rdoMade);
      }
      data.setOld();
    }
    if (inData & 0x4) { // Error in the first hit
      ATH_MSG_DEBUG("    Hit condensed : xxx ERROR in 1st hit" << std::hex << inData);
      data.errorHit.push_back(data.groupSize);
      m_condHit1Error++;
      data.errors = (data.errors | 0x10);
      hasError = true;
    }
    if (inData & 0x8) { // Error in the second hit
      ATH_MSG_DEBUG("    Hit condensed : xxx ERROR in 2nd hit" << std::hex << inData);
      data.errorHit.push_back(data.groupSize);
      m_condHit2Error++;
      data.errors = (data.errors | 0x20);
      hasError = true;
    }
    data.groupSize = 2;
  }
 
  return sc;
}

processExpandedHit()

StatusCode SCT_RodDecoder::processExpandedHit ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RDO_Container & rdoIDCont, DataPool< SCT3_RawData > * dataItemsPool, CacheHelper & cache, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process hit word in Expanded mode.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
rdoIDCont	RDO ID Container to be filled.
cache	Cache.
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 1002 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
 
  int chip{0};
  if (not (inData & 0x8)) {  // 1st hit cluster expanded
    m_firstExpHitNumber++;
    chip = ((inData>>11) & 0x7);
    data.side = ((inData>>14) & 0x1);
    data.strip = chip*N_STRIPS_PER_CHIP + ((inData>>4) & 0x7F);
    data.timeBin = (inData & 0x7); // Real way for obtaining timeBin info
 
    if (chip>=N_CHIPS_PER_SIDE) {
      ATH_MSG_DEBUG("Expanded hit: First hit xxx ERROR chip Nb = " << chip << " >= " << N_CHIPS_PER_SIDE);
      m_chipNumberError++;
      ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      return sc;
    }
 
    // Search for redundancy only for the master chip
    bool secondSide{false};
    if ((data.side==1) and ((data.linkNumber%2)==0))  {
      data.linkNumber++;
      secondSide = true;
    }
    else if ((data.side==0) and ((data.linkNumber%2)!=0)) {
      data.linkNumber--;
      secondSide = true;
    }
    if (secondSide) {
      const uint32_t onlineID{(robID & 0xFFFFFF) | (data.linkNumber << 24)};
      data.setCollection(m_sctID, m_cabling->getHashFromOnlineId(onlineID, ctx), rdoIDCont, dataItemsPool, errs);
    }
    data.groupSize = 1;
    const int rdoMade{makeRDO(false, data, cache, dataItemsPool)};
    if (rdoMade == -1) {
      hasError = true;
      ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
    }
    else {
      data.setSaved(false, rdoMade);
    }
    data.groupSize = 0;
  }
  else { // Next hits cluster expanded
    if (inData & 0x80) { // Paired hits
      if (data.strip >= N_STRIPS_PER_SIDE-2) {
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
        hasError = true;
        ATH_MSG_DEBUG("Expanded mode - strip number out of range");
        return sc;
      }
      m_evenExpHitNumber++;
      // First hit from the pair
      data.strip++;
      data.timeBin = (inData & 0x7);
      data.groupSize = 1;
      const int rdoMade1{makeRDO(false, data, cache, dataItemsPool)};
      if (rdoMade1 == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(false, rdoMade1);
      }
      // Second hit from the pair
      data.strip++;
      data.timeBin = ((inData >> 4) & 0x7);
      const int rdoMade2{makeRDO(false, data, cache, dataItemsPool)};
      if (rdoMade2 == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(false, rdoMade2);
      }
      data.groupSize = 0;
    }
    else { // Last hit of the cluster
      m_lastExpHitNumber++;
      if (data.strip >= N_STRIPS_PER_SIDE-1) {
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
        hasError = true;
        ATH_MSG_DEBUG("Expanded mode - strip number out of range");
        return sc;
      }
      data.strip++;
      data.timeBin = (inData & 0x7);
      data.groupSize = 1;
      const int rdoMade{makeRDO(false, data, cache, dataItemsPool)};
      if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
      }
      else {
        data.setSaved(false, rdoMade);
      }
      data.groupSize = 0;
    }
  }
 
  return sc;
}

processHeader()

StatusCode SCT_RodDecoder::processHeader ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RDO_Container & rdoIDCont, DataPool< SCT3_RawData > * dataItemsPool, CacheHelper & cache, SCT_RodDecoderErrorsHelper & errs, bool & hasError, bool & breakNow, const EventContext & ctx ) const

private

Process header word.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
rdoIDCont	RDO ID Container to be filled.
cache	Cache.
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
breakNow	to tell if need to break after this method execution.
ctx	EventContext

Definition at line 660 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
 
  data.foundHeader = true;
  m_headNumber++;
 
  // Create the last RDO of the previous link if any
  if (data.isStripValid()) {
     if (not data.isSaved(false) and data.isOldStripValid()) {
 
        const int rdoMade{makeRDO(false, data, cache, dataItemsPool)};
        if (rdoMade == -1) {
           hasError = true;
           ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
        }
        else {
           data.setSaved(false, rdoMade);
        }
     }
  }
 
  // Everything is set to default for a new hunt of RDO
  data.reset();
 
  // Link Number (or stream) in the ROD fragment
  const int rodlinkNumber{static_cast<int>(inData & 0x7F)};
 
  // This is the real calculation for the offline
  data.linkNumber = (((rodlinkNumber >>4)&0x7)*12+(rodlinkNumber &0xF));
  const uint32_t onlineID{(robID & 0xFFFFFF) | (data.linkNumber << 24)};
  IdentifierHash hash;
  if ((onlineID ==0) or (data.linkNumber > 95)) {
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
    hasError = true;
    ATH_MSG_DEBUG("Header: xxx Link number out of range (skipping following data)"
                  << std::dec << data.linkNumber);
    breakNow = true;
    return sc;
  }
  else {
    hash = m_cabling->getHashFromOnlineId(onlineID, ctx);
    if (hash.is_valid()) {
       data.setCollection(m_sctID, hash, rdoIDCont, dataItemsPool, errs);
    }
    else {
       std::stringstream msg;
       msg <<std::hex << onlineID;
       ATH_MSG_WARNING("Rob fragment (rob=" << robID << ") with invalid onlineID  " << msg.str() << " -> " << hash  << ".");
    }
  }
  // Look for masked off links - bit 7
  if ((inData >> 7) & 0x1) {
    ATH_MSG_DEBUG("Masked link " << onlineID << " " << data.linkIDHash);
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::MaskedLink, errs, ctx));
    hasError = true;
  }
  if (inData & 0x800) {
    ATH_MSG_DEBUG("    Header: xxx TimeOut Error " << data.linkIDHash);
    m_headErrorTimeout++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::TimeOutError, errs, ctx));
    hasError = true;
  }
  
  if (inData & 0x1000) {
    ATH_MSG_DEBUG("    Header: xxx Preamble Error " << data.linkIDHash);
    m_headErrorPreamble++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::PreambleError, errs, ctx));
    hasError = true;
  }
 
  if (inData & 0x400) {
    ATH_MSG_DEBUG("    Header: xxx LVL1 ID Error " << data.linkIDHash);
    m_headErrorLvl1ID++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::LVL1IDError, errs, ctx));
    hasError = true;
  }
  
  if (inData & 0x200) {
    ATH_MSG_DEBUG("    Header: xxx BCID Error " << data.linkIDHash);
    m_headErrorBCID++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::BCIDError, errs, ctx));
    hasError = true;
  }
  
  if ((inData & 0xF) > 11) {
    ATH_MSG_DEBUG("    Header: xxx Error in formatter " << data.linkIDHash);
    m_headErrorFormatter++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::FormatterError, errs, ctx));
    hasError = true;
  }
  if (!hasError and not hash.is_valid())  {
    std::stringstream msg;
    msg <<std::hex << onlineID;
    ATH_MSG_WARNING("Rob fragment (rob=" << robID << ") with invalid onlineID  " << msg.str() << " -> " << hash  << ".");
    hasError = true;
  }
 
  data.condensedMode = static_cast<bool>(inData & 0x100);
 
  return sc;
}

processRawData()

StatusCode SCT_RodDecoder::processRawData ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process raw data word.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 1181 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
 
  if (not data.foundHeader) {
    ATH_MSG_INFO(" Missing link header in ROD " << std::hex << robID << std::dec);
    data.foundMissingLinkHeaderError = true;
    m_numMissingLinkHeader++;
    hasError = true;
    return sc;
  }
 
  ATH_MSG_DEBUG(" xxx Raw Data Mode " << std::hex << inData << std::dec << ": Config Data Mode ");
  // Too many errors in the BS for the ROD to decode the data
  m_configDataBit++;
  ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::RawError, errs, ctx));
  hasError = true;
 
  return sc;
}

processSuperCondensedHit()

StatusCode SCT_RodDecoder::processSuperCondensedHit ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RDO_Container & rdoIDCont, DataPool< SCT3_RawData > * dataItemsPool, CacheHelper & cache, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process hit word in Super-Condensed mode.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
rdoIDCont	RDO ID Container to be filled.
cache	Cache.
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 772 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
 
  // Super-condensed mode:
  // Chip info: 4 bits  data16[n]>>11) & 0xF
  // Chip number == (data16[n]>>11) & 0x7
  // Chip side == (data16[n]>>14) & 0x1
  // For example if (data16[n]>>11) & 0xF = 0b0101 => chip 5 or chip5 on side0, (data16[n]>>11) & 0xF = 0b1101 => chip13 or chip5 on side1
  const int chip{(inData>>11) & 0x7};
  data.side = ((inData>>14) & 0x1);
  data.strip = chip*N_STRIPS_PER_CHIP + ((inData>>4) & 0x7F);
  data.timeBin = 0x2; // Assuming timeBin is 010 in super-condensed mode
  const int nStripsInWord{(inData & 0xF)+1};
  if (chip>=N_CHIPS_PER_SIDE) {
    ATH_MSG_DEBUG("    Hit super-condensed : xxx Chip number = " << chip << " >= "<< N_CHIPS_PER_SIDE << " for hit "
                  << std::hex << inData);
    m_chipNumberError++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
    hasError = true;
    return sc;
  }
 
  // Search for redundancy only for the master chip
  bool secondSide{false};
  if ((data.side==1) and ((data.linkNumber%2)==0)) {
    if (((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) and (data.groupSize>0)) {
      // If it is a new cluster, make RDO with the previous cluster
       const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
       if (rdoMade == -1) {
          hasError = true;
          ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
       }
       else {
          data.setSaved(true, rdoMade);
       }
      data.setOld();
    }
    data.linkNumber++;
    secondSide = true;
  }
  else if ((data.side==0) and ((data.linkNumber%2)!=0)) {
    if (((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) and (data.groupSize>0)) {
      // If it is a new cluster, make RDO with the previous cluster
       const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
       if (rdoMade == -1) {
          hasError = true;
          ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
       }
       else {
          data.setSaved(true, rdoMade);
       }
      data.setOld();
    }
    data.linkNumber--;
    secondSide = true;
  }
  if (secondSide) {
    const uint32_t onlineID{(robID & 0xFFFFFF) | (data.linkNumber << 24)};
    IdentifierHash id_hash(m_cabling->getHashFromOnlineId(onlineID,ctx));
    if (!id_hash.is_valid()) {
       hasError = true;
       return sc;
    }
    data.setCollection(m_sctID, id_hash, rdoIDCont, dataItemsPool, errs);
  }
 
  if (data.groupSize == 0)  {
    data.setOld(); // If it's the first super-condensed word
  }
 
  if ((data.strip!=data.oldStrip) or (data.side!=data.oldSide)) {
    // If it is a new cluster, make RDO with the previous cluster
     const int rdoMade{makeRDO(true, data, cache, dataItemsPool)};
     if (rdoMade == -1) {
        hasError = true;
        ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::ByteStreamParseError, errs, ctx));
     }
     else {
        data.setSaved(true, rdoMade);
     }
     data.setOld();
  }
  data.groupSize += nStripsInWord; // Split clusters have the same strip number.
 
  return sc;
}

processTrailer()

StatusCode SCT_RodDecoder::processTrailer ( const uint16_t inData, const uint32_t robID, SharedData & data, SCT_RodDecoderErrorsHelper & errs, bool & hasError, const EventContext & ctx ) const

private

Process trailer word.

Parameters

inData	input 16 bit data word for header
robID	ROB ID
data	Struct to hold data shared in methods used in fillCollection method
errs	SCT_RodDecoderErrorsHelper to fill IDCInDetBSErrContainer
hasError	false means no error, true means at least one error
ctx	EventContext

Definition at line 1207 of file SCT_RodDecoder.cxx.

{
  StatusCode sc{StatusCode::SUCCESS};
  /* Temporarily disabled
  if (not data.foundHeader) {
    ATH_MSG_INFO(" Missing link header in ROD " << std::hex << robID << std::dec);
    data.foundMissingLinkHeaderError = true;
    m_numMissingLinkHeader++;
    hasError = true;
  }
  */
 
  data.foundHeader = false;
 
  m_trailerNumber++;
 
  if (inData & 0x1000) {
    ATH_MSG_DEBUG("    Trailer: xxx Trailer ERROR " << std::hex << inData);
    m_trailerErrorBit++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::TrailerError, errs, ctx));
    hasError = true;
  }
 
  if (inData & 0x800) {
    // No data should appear between header and trailer
    // See 1.2.2 Formatter FPGA - Serial Data Decoding and Formatting of
    // http://www-eng.lbl.gov/~jmjoseph/Atlas-SiROD/Manuals/usersManual-v164.pdf
    ATH_MSG_DEBUG("    Trailer: xxx Header-Trailer limit ERROR " << std::hex << inData);
    m_trailerErrorLimit++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::HeaderTrailerLimitError, errs, ctx));
    hasError = true;
  }
 
  if (inData & 0x400) {
    // Not sure if there are hit elements before (probably yes but in principle they are fine)
    ATH_MSG_DEBUG("    Trailer: xxx Data Overflow ERROR " << std::hex << inData);
    m_trailerErrorOverflow++;
    ATH_CHECK(addSingleError(data.linkIDHash, SCT_ByteStreamErrors::TrailerOverflowError, errs, ctx));
    hasError = true;
  }
  if (inData & 0xF) {
    // First temporarily masked chip information
    // 0 means no masked chip (always has been 0 until April 2017)
    //
    // If Rx redundacy is not used,
    // 1 means chips 0-5 are temporarily masked.
    // 6 means chip 5 is temporarily masked.
    // 7 means chips 6-11 are temporarily masked.
    // 12 means chip 11 is temporarily masked.
    //
    // If Rx redundacy is used and link-1 is not used,
    // 1 means chips 0-11 are temporarily masked.
    // 6 means chips 5-11 are temporarily masked.
    // 7 means chips 6-11 are temporarily masked.
    // 12 means chip 11 is temporarily masked.
    //
    // If Rx redundacy is used and link-0 is not used,
    // 1 means chips 0-5 are temporarily masked.
    // 6 means chip 5 is temporarily masked.
    // 7 means chips 6-11, 0-5 are temporarily masked.
    // 12 means chips 11, 0-5 are temporarily masked.
    setFirstTempMaskedChip(data.linkIDHash, (inData & 0xF), errs, ctx).ignore();
  }
 
  return sc;
}

setFirstTempMaskedChip()

StatusCode SCT_RodDecoder::setFirstTempMaskedChip ( const IdentifierHash & hashID, unsigned int firstTempMaskedChip, SCT_RodDecoderErrorsHelper & errs, const EventContext & ctx ) const

private

Set first temporarily masked chip information from byte stream trailer.

Parameters

hashID	Identifier for hash.
firstTempMaskedChip	Firt temporarily masked chip info.
errs	Byte stream error container.
ctx	EventContext

Definition at line 495 of file SCT_RodDecoder.cxx.

{
  if (not hashID.is_valid()) {
    ATH_MSG_INFO("setFirstTempMaskedChip hashID " << hashID << " is invalid.");
    return StatusCode::RECOVERABLE;
  }
  if (firstTempMaskedChip==0) {
    ATH_MSG_WARNING("setFirstTempMaskedChip: firstTempMaskedChip should be greater than 0. firstTempMaskedChip is "
                    << firstTempMaskedChip);
    return StatusCode::RECOVERABLE;
  }
 
  // wafer hash -> wafer id -> module id -> wafer hash on side-0, wafer hash on side-1
  const Identifier waferID{m_sctID->wafer_id(hashID)};
  const Identifier moduleID{m_sctID->module_id(waferID)};
 
  // Side 0
  IdentifierHash hashSide0;
  m_sctID->get_hash(moduleID, hashSide0, &m_contextSCT);
  unsigned int firstTempMaskedChipSide0{0};
  if (hashID==hashSide0) firstTempMaskedChipSide0 = firstTempMaskedChip;
 
  // Side 1
  IdentifierHash hashSide1;
  m_sctID->get_other_side(hashSide0, hashSide1);
  unsigned int firstTempMaskedChipSide1{0};
  if (hashID==hashSide1) firstTempMaskedChipSide1 = firstTempMaskedChip;
 
  int type{0};
  // Check if Rx redundancy is used or not in this module
  const std::pair<bool, bool> badLinks{m_configTool->badLinks(hashID, ctx)};
  if (badLinks.first xor badLinks.second) {
    // Rx redundancy is used in this module.
    if (badLinks.first and not badLinks.second) {
      // link-1 is broken
      type = 1;
    }
    else if (badLinks.second and not badLinks.first) {
      // link-0 is broken
      type = 2;
    }
    else if (badLinks.first and badLinks.second) {
      // Both link-0 and link-1 are working
      ATH_MSG_WARNING("setFirstTempMaskedChip: Both link-0 and link-1 are working. But Rx redundancy is used... Why?");
      return StatusCode::RECOVERABLE;
    }
    else {
      // Both link-0 and link-1 are broken
      ATH_MSG_WARNING("setFirstTempMaskedChip: Both link-0 and link-1 are broken. But data are coming... Why?");
      return StatusCode::RECOVERABLE;
    }
  }
 
  // "Modified" module (using Rx redundancy) case
  // Information of modified modules are found in
  // modified0 and modified1 functions of SCT_ReadoutTool.cxx and
  // Table 3.8 of CERN-THESIS-2008-001 https://cds.cern.ch/record/1078223
  // However, there are two exceptions of the exceptions.
  const unsigned long long fullSerialNumber{m_cabling->getSerialNumberFromHash(hashID).to_ulonglong()};
  if (// Readout through link-0
      fullSerialNumber==20220170200183 or // hash=4662 bec=0 layer=2 eta= 6 phi=39
      fullSerialNumber==20220330200606 or // hash=5032 bec=0 layer=3 eta=-2 phi= 7
      fullSerialNumber==20220330200693    // hash=5554 bec=0 layer=3 eta=-5 phi=29
      ) {
    if (type!=1) ATH_MSG_WARNING("Link-0 is broken but modified module readingout link-0, inconsistent");
    type = 3;
 
    // An exception:
    // fullSerialNumber=20220170200941, hash=3560 bec=0 layer=1 eta=-6 phi=34
    // This module is a modified one. However, it is not using modified configuration.
    // Readout sequence is 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11.
  }
  if (// Readout through link-1
      fullSerialNumber==20220170200653 or // hash=2786 bec=0 layer=1 eta= 4 phi= 1
      fullSerialNumber==20220330200117 or // hash=5516 bec=0 layer=3 eta= 1 phi=27
      fullSerialNumber==20220330200209 or // hash=5062 bec=0 layer=3 eta= 2 phi= 8
      fullSerialNumber==20220330200505 or // hash=5260 bec=0 layer=3 eta= 5 phi=16
      fullSerialNumber==20220330200637 or // hash=4184 bec=0 layer=2 eta=-6 phi=20
      fullSerialNumber==20220330200701    // hash=4136 bec=0 layer=2 eta=-6 phi=18
      ) {
    if (type!=2) ATH_MSG_WARNING("Link-1 is broken but modified module readingout link-1, inconsistent");
    type = 4;
 
    // Another exception:
    // fullSerialNumber=20220170200113, hash=3428 bec=0 layer=1 eta= 1 phi=28
    // This module is a modified one. However, it is not using modified configuration.
    // Readout sequence is 6, 7, 8, 9, 10, 11, 1, 2, 3, 4, 5.
  }
 
  static const int chipOrder[5][N_SIDES*N_CHIPS_PER_SIDE]{
    // type=0 not prepared for both link-0 and link-1 are working
    {},
    // type=1 link-1 is broken: chip 0 1 2 3 4 5 6 7 8 9 10 11
    {0, 1, 2, 3,  4,  5, 6, 7, 8,  9, 10, 11},
    // type=2 link-0 is broken: chip 6 7 8 9 10 11 0 1 2 3 4 5
    {6, 7, 8, 9, 10, 11, 0, 1, 2,  3,  4,  5},
    // type=3 "modified" modules and link-1 is broken: chip 0 1 2 3 4 5 7 8 9 10 11 6
    {0, 1, 2, 3,  4,  5, 7, 8, 9, 10, 11,  6},
    // type=4 "modified" modules and link-0 is broken: chip 6 7 8 9 10 11 1 2 3 4 5 0
    {6, 7, 8, 9, 10, 11, 1, 2, 3,  4,  5,  0}
  };
 
  if (type==0) {
    // Both link-0 and link-1 are working
 
    // Chips 0-5 are on side 0 and chips 6-11 are on side 1.
    // Normally, modules send hits on side 0 via link-0 and side 1 via link-1.
    // The first temporally masked chip value is the id of the chip that is
    // first masked in the readout chain "plus one".
    // If the value is in between 1 to  6, it indicates side 0.
    // If the value is in between 7 to 12, it indicates side 1.
    // However, some special modules send hits on side 0 via link-1 and hits on
    // side 1 via link-0. If the first masked chip value on side 1 (0) is
    // between 1 to 6 (7 to 12), it indicates the module is a special one.
    // In that case, information is swapped.
    if ((N_CHIPS_PER_SIDE<firstTempMaskedChipSide0 and firstTempMaskedChipSide0<=N_SIDES*N_CHIPS_PER_SIDE) or
        (               0<firstTempMaskedChipSide1 and firstTempMaskedChipSide1<=        N_CHIPS_PER_SIDE)) {
      const unsigned int swapFirstTempMaskedChipSide0{firstTempMaskedChipSide0};
      firstTempMaskedChipSide0 = firstTempMaskedChipSide1;
      firstTempMaskedChipSide1 = swapFirstTempMaskedChipSide0;
    }
 
    if (firstTempMaskedChipSide0>0) {
      for (unsigned int iChip{firstTempMaskedChipSide0-1}; iChip<N_CHIPS_PER_SIDE; iChip++) {
        ATH_CHECK(addSingleError(hashSide0, SCT_ByteStreamErrors::TempMaskedChipToBit(iChip), errs, ctx));
      }
    }
    if (firstTempMaskedChipSide1>N_CHIPS_PER_SIDE) {
      for (unsigned int iChip{firstTempMaskedChipSide1-1}; iChip<N_SIDES*N_CHIPS_PER_SIDE; iChip++) {
        ATH_CHECK(addSingleError(hashSide1, SCT_ByteStreamErrors::TempMaskedChipToBit(iChip-N_CHIPS_PER_SIDE), errs, ctx));
      }
    }
  }
  else {
    // type=1, 2, 3, 4: cases using Rx redundancy
    bool toBeMasked{false};
    for (int iChip{0}; iChip<N_SIDES*N_CHIPS_PER_SIDE; iChip++) {
      int jChip{chipOrder[type][iChip]};
      if (jChip==static_cast<int>(firstTempMaskedChip-1)) toBeMasked = true;
      if (toBeMasked) {
        if (jChip<N_CHIPS_PER_SIDE) {
          ATH_CHECK(addSingleError(hashSide0, SCT_ByteStreamErrors::TempMaskedChipToBit(jChip), errs, ctx));
        }
        else {
          ATH_CHECK(addSingleError(hashSide1, SCT_ByteStreamErrors::TempMaskedChipToBit(jChip-N_CHIPS_PER_SIDE), errs, ctx));
        }
      }
    }
  }
 
  ATH_MSG_VERBOSE("setFirstTempMaskedChip Hash " << hashID
                  << " SerialNumber " << m_cabling->getSerialNumberFromHash(hashID).str()
                  << " moduleID " << moduleID
                  << " barrel_ec " << m_sctID->barrel_ec(waferID)
                  << " layer_disk " << m_sctID->layer_disk(waferID)
                  << " eta_module " << m_sctID->eta_module(waferID)
                  << " phi_module " << m_sctID->phi_module(waferID)
                  << " side " << m_sctID->side(waferID)
                  << " firstTempMaskedChip " << firstTempMaskedChip);
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_cabling

ToolHandle<ISCT_CablingTool> SCT_RodDecoder::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 444 of file SCT_RodDecoder.h.

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

m_chipNumberError

std::atomic_uint SCT_RodDecoder::m_chipNumberError {0}

mutableprivate

Total number of chip number errors.

Definition at line 513 of file SCT_RodDecoder.h.

{0};

m_condHit1Error

std::atomic_uint SCT_RodDecoder::m_condHit1Error {0}

mutableprivate

Total number of first hit data errors.

Definition at line 507 of file SCT_RodDecoder.h.

{0};

m_condHit2Error

std::atomic_uint SCT_RodDecoder::m_condHit2Error {0}

mutableprivate

Total number second hit data errors.

Definition at line 510 of file SCT_RodDecoder.h.

{0};

m_configDataBit

std::atomic_uint SCT_RodDecoder::m_configDataBit {0}

mutableprivate

Total number of configuration data for raw data.

Definition at line 501 of file SCT_RodDecoder.h.

{0};

m_configTool

ToolHandle<ISCT_ConfigurationConditionsTool> SCT_RodDecoder::m_configTool

private

Initial value:

{this, 
                                                            "ConfigTool",
                                                            "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", 
                                                            "Tool to retrieve SCT Configuration Tool"}

Service that keeps track of configuration conditions.

Definition at line 450 of file SCT_RodDecoder.h.

                                                           {this, 
                                                            "ConfigTool",
                                                            "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", 
                                                            "Tool to retrieve SCT Configuration Tool"};

m_contextSCT

IdContext SCT_RodDecoder::m_contextSCT

private

"Context" of an expanded identifier (ExpandedIdentifier) for compact or hash versions (Identifier32 or IdentifierHash)

Definition at line 441 of file SCT_RodDecoder.h.

m_evenExpHitNumber

std::atomic_uint SCT_RodDecoder::m_evenExpHitNumber {0}

mutableprivate

Total number of consecutive paired strips with hit decoded in expanded mode.

Definition at line 465 of file SCT_RodDecoder.h.

{0};

m_firstExpHitNumber

std::atomic_uint SCT_RodDecoder::m_firstExpHitNumber {0}

mutableprivate

Total number of first strips with hit decoded in expanded mode.

Definition at line 462 of file SCT_RodDecoder.h.

{0};

m_flagErrorBit

std::atomic_uint SCT_RodDecoder::m_flagErrorBit {0}

mutableprivate

Total number of flag error data.

Definition at line 504 of file SCT_RodDecoder.h.

{0};

m_headErrorBCID

std::atomic_uint SCT_RodDecoder::m_headErrorBCID {0}

mutableprivate

Total number of BCID errors in the header data.

Definition at line 477 of file SCT_RodDecoder.h.

{0};

m_headErrorFormatter

std::atomic_uint SCT_RodDecoder::m_headErrorFormatter {0}

mutableprivate

Total number of formatter errors in the header data.

Definition at line 486 of file SCT_RodDecoder.h.

{0};

m_headErrorLvl1ID

std::atomic_uint SCT_RodDecoder::m_headErrorLvl1ID {0}

mutableprivate

Total number of Lvl1ID errors in the header data.

Definition at line 480 of file SCT_RodDecoder.h.

{0};

m_headErrorPreamble

std::atomic_uint SCT_RodDecoder::m_headErrorPreamble {0}

mutableprivate

Total number of preamble errors in the header data.

Definition at line 489 of file SCT_RodDecoder.h.

{0};

m_headErrorTimeout

std::atomic_uint SCT_RodDecoder::m_headErrorTimeout {0}

mutableprivate

Total number of timeout errors in the header data.

Definition at line 483 of file SCT_RodDecoder.h.

{0};

m_headNumber

std::atomic_uint SCT_RodDecoder::m_headNumber {0}

mutableprivate

Total number of decoded header data.

Definition at line 471 of file SCT_RodDecoder.h.

{0};

m_lastExpHitNumber

std::atomic_uint SCT_RodDecoder::m_lastExpHitNumber {0}

mutableprivate

Total number of last consecutive strips with hit decoded in expanded mode.

Definition at line 468 of file SCT_RodDecoder.h.

{0};

m_maskedLinkNumber

std::atomic_uint SCT_RodDecoder::m_maskedLinkNumber {0}

mutableprivate

Total number of masked links in the header data.

Definition at line 525 of file SCT_RodDecoder.h.

{0};

m_maskedRODNumber

std::atomic_uint SCT_RodDecoder::m_maskedRODNumber {0}

mutableprivate

Total number of masked RDOs.

Definition at line 528 of file SCT_RodDecoder.h.

{0};

m_nHits

std::atomic_uint SCT_RodDecoder::m_nHits {0}

mutableprivate

Total number of SCT hits in ByteStream.

Definition at line 519 of file SCT_RodDecoder.h.

{0};

m_nRDOs

std::atomic_uint SCT_RodDecoder::m_nRDOs {0}

mutableprivate

Total number of SCT RDOs created.

Definition at line 522 of file SCT_RodDecoder.h.

{0};

m_numMissingLinkHeader

std::atomic_uint SCT_RodDecoder::m_numMissingLinkHeader {0}

mutableprivate

Total number of missing link headers.

Definition at line 537 of file SCT_RodDecoder.h.

{0};

m_pairedCondHitNumber

std::atomic_uint SCT_RodDecoder::m_pairedCondHitNumber {0}

mutableprivate

Total number of paired strips with hit decoded in condensed mode.

Definition at line 459 of file SCT_RodDecoder.h.

{0};

m_rodClockErrorNumber

std::atomic_uint SCT_RodDecoder::m_rodClockErrorNumber {0}

mutableprivate

Total number of ROD clock errors.

Definition at line 531 of file SCT_RodDecoder.h.

{0};

m_sctID

const SCT_ID* SCT_RodDecoder::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 437 of file SCT_RodDecoder.h.

{nullptr};

m_singleCondHitNumber

std::atomic_uint SCT_RodDecoder::m_singleCondHitNumber {0}

mutableprivate

Total number of single strips with hit decoded in condensed mode.

Definition at line 456 of file SCT_RodDecoder.h.

{0};

m_swapPhiReadoutDirection

std::vector<bool> SCT_RodDecoder::m_swapPhiReadoutDirection {}

private

Swap phi readout direction.

Definition at line 540 of file SCT_RodDecoder.h.

{};

m_trailerErrorBit

std::atomic_uint SCT_RodDecoder::m_trailerErrorBit {0}

mutableprivate

Total number of trailer bit errors.

Definition at line 498 of file SCT_RodDecoder.h.

{0};

m_trailerErrorLimit

std::atomic_uint SCT_RodDecoder::m_trailerErrorLimit {0}

mutableprivate

Total number of header trailer limit errors in the trailer data.

Definition at line 495 of file SCT_RodDecoder.h.

{0};

m_trailerErrorOverflow

std::atomic_uint SCT_RodDecoder::m_trailerErrorOverflow {0}

mutableprivate

Total number of overflow errors in the trailer data.

Definition at line 492 of file SCT_RodDecoder.h.

{0};

m_trailerNumber

std::atomic_uint SCT_RodDecoder::m_trailerNumber {0}

mutableprivate

Total number of decoded trailer data.

Definition at line 474 of file SCT_RodDecoder.h.

{0};

m_truncatedRODNumber

std::atomic_uint SCT_RodDecoder::m_truncatedRODNumber {0}

mutableprivate

Total number of truncated ROBFragments.

Definition at line 534 of file SCT_RodDecoder.h.

{0};

m_unknownDataFormat

std::atomic_uint SCT_RodDecoder::m_unknownDataFormat {0}

mutableprivate

Total number of unknown data formats.

Definition at line 516 of file SCT_RodDecoder.h.

{0};

---

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

• SCT_RodDecoder.h
• SCT_RodDecoder.cxx