SCT_ByteStreamErrorsTool Class Reference

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

#include <SCT_ByteStreamErrorsTool.h>

Inheritance diagram for SCT_ByteStreamErrorsTool:

Collaboration diagram for SCT_ByteStreamErrorsTool:

Classes
struct	IDCCacheEntry

Public Member Functions
	SCT_ByteStreamErrorsTool (const std::string &type, const std::string &name, const IInterface *parent)
	header file for this class.
virtual	~SCT_ByteStreamErrorsTool ()=default
virtual StatusCode	initialize () override
	Initialize.
virtual StatusCode	finalize () override
	Finalize.
virtual bool	canReportAbout (InDetConditions::Hierarchy h) const override
	Used by ConditionsSummayTool to decide whether to call isGood() for a particular detector element.
virtual bool	isGood (const Identifier &elementId, const EventContext &ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override
	Is the detector element good?
virtual bool	isGood (const IdentifierHash &elementIdHash, const EventContext &ctx) const override
	this is the principle method which can be accessed via the ConditionsSummaryTool to decide if a wafer is good - in this case we want to return false if the wafer has an error that would result in bad hits or no hits for that event
virtual void	getDetectorElementStatus (const EventContext &ctx, InDet::SiDetectorElementStatus &element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override
virtual std::set< IdentifierHash >	getErrorSet (int errorType, const EventContext &ctx) const override
	The accessor method that can be used by clients to retrieve a set of IdHashes of wafers with a given type of error.
virtual unsigned int	tempMaskedChips (const Identifier &moduleId, const EventContext &ctx) const override
virtual unsigned int	abcdErrorChips (const Identifier &moduleId, const EventContext &ctx) const override

Private Types
enum	N_ELEMENTS { N_CHIPS_PER_SIDE = 6 , N_SIDES = 2 , N_STRIPS_PER_CHIP = 128 , N_STRIPS_PER_SIDE = N_STRIPS_PER_CHIP*N_CHIPS_PER_SIDE }

Private Member Functions
const IDCInDetBSErrContainer *	getContainer (const EventContext &ctx) const
	Obtains container form the SG, if it is missing it will complain (hard-coded 3 times per job) and return nullptr.
IDCCacheEntry *	getCacheEntry (const EventContext &ctx) const
	Return cache for the current event If, for current slot, the cache is outdated it is retrieved from the IDC collection.
StatusCode	fillData (const EventContext &ctx) const
	Updates information per module & ABCD chip.
bool	isGoodChip (const Identifier &stripId, const EventContext &ctx) const
int	getChip (const Identifier &stripId, const EventContext &ctx) const
const InDetDD::SiDetectorElement *	getDetectorElement (const IdentifierHash &waferHash, const EventContext &ctx) const
std::pair< StatusCode, unsigned int >	getErrorCodeWithCacheUpdate (const Identifier &id, const EventContext &ctx, std::unordered_map< size_t, unsigned int > &whereExected) const
	Method that returns BS Error code from the map passed @rag where-Expected If the information is initially missing, the cache update is triggered.

Private Attributes
ToolHandle< ISCT_ConfigurationConditionsTool >	m_config
SG::ReadHandleKey< IDCInDetBSErrContainer >	m_bsIDCErrContainerName {this, "IDCByteStreamErrContainer", "SCT_ByteStreamErrs", "SCT BS error key for IDC variant"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
const SCT_ID *	m_sct_id {nullptr}
IdContext	m_cntx_sct
uint64_t	m_badErrorMask {}
SG::SlotSpecificObj< std::mutex > m_cacheMutex	ATLAS_THREAD_SAFE
SG::SlotSpecificObj< IDCCacheEntry > m_eventCache	ATLAS_THREAD_SAFE
std::atomic_uint	m_nRetrievalFailure {0}

Detailed Description

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

The API offers two levels of access, 1) by identifier 2) for "all event" In 1st case the information from entire event is used via the cache if IDC container that keeps an information about errors for so far decoded SCT data. That access pattern is identical for HLT and offline use-case. Missing data in the cache is sign of error.

The 2nd patter is to request error information for the whole event. In case of trigger these methods can in fact return information for the fragment of the detector data. This depends on the IDC container that the tool is configured to read.

There are two levels of caching involved in data access. First the IDC stores actual BS error codes in the event-wide container called cache. Even if the IDC container may be different, this cache remains the same for the whole event. Secondly the tool itself has a cache that is essentially needed to avoid going to the event store for the IDC container for each call. Inside this local cache object derived information is stored to speed up calls like isGood.

Definition at line 64 of file SCT_ByteStreamErrorsTool.h.

Member Enumeration Documentation

N_ELEMENTS

enum SCT_ByteStreamErrorsTool::N_ELEMENTS

private

Enumerator
N_CHIPS_PER_SIDE
N_SIDES
N_STRIPS_PER_CHIP
N_STRIPS_PER_SIDE

Definition at line 90 of file SCT_ByteStreamErrorsTool.h.

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

Constructor & Destructor Documentation

SCT_ByteStreamErrorsTool()

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

header file for this class.

Athena includes Constructor

Definition at line 23 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                         :
  base_class(type, name, parent)
{
}

~SCT_ByteStreamErrorsTool()

virtual SCT_ByteStreamErrorsTool::~SCT_ByteStreamErrorsTool ( )

virtualdefault

Member Function Documentation

abcdErrorChips()

unsigned int SCT_ByteStreamErrorsTool::abcdErrorChips ( const Identifier & moduleId, const EventContext & ctx ) const

overridevirtual

Definition at line 433 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                               {
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool abcdErrorChips");
  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
  auto *cacheEntry{getCacheEntry(ctx)};
  if (cacheEntry->IDCCache == nullptr) {
    ATH_MSG_VERBOSE("cacheEntry->IDCCache == nullptr");
    return 0;
  }
 
  auto [status, v_abcdErrorChips] = getErrorCodeWithCacheUpdate(moduleId, ctx, cacheEntry->abcdErrorChips);
  if (status.isFailure()) {
    ATH_MSG_ERROR("SCT_ByteStreamErrorsTool Failure getting ABCD chip errors");
  }
  return v_abcdErrorChips; // 12 bits are used.
  // Bit 0 is for chip 0 on side 0, bit 1 is for chip 1 on side 0, ..., and bit 11 is for chip 5 on side 1
}

canReportAbout()

bool SCT_ByteStreamErrorsTool::canReportAbout ( InDetConditions::Hierarchy h ) const

overridevirtual

Used by ConditionsSummayTool to decide whether to call isGood() for a particular detector element.

In principle we could report about modules and/or strips too, and use the id helper to navigate up or down the hierarchy to the wafer, but in practice we don't want to do the time-consuming isGood() for every strip, so lets only report about wafers..

Definition at line 67 of file SCT_ByteStreamErrorsTool.cxx.

                                                                         {
  return (h==InDetConditions::SCT_SIDE or h==InDetConditions::SCT_CHIP);
}

fillData()

StatusCode SCT_ByteStreamErrorsTool::fillData ( const EventContext & ctx ) const

private

Updates information per module & ABCD chip.

this function is used to populate the data of this tool from the InDetBSErrContainer in StoreGate

OK, so we found the StoreGate container, now lets iterate over it to populate the sets of errors owned by this Tool.

Definition at line 344 of file SCT_ByteStreamErrorsTool.cxx.

                                                                {
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool fillData");
 
  const IDCInDetBSErrContainer* idcErrCont{getContainer(ctx)};
  if (idcErrCont == nullptr) {
    ATH_MSG_VERBOSE("idcErrCont == nullptr");
    return StatusCode::SUCCESS;
  }
 
  auto *cacheEntry{getCacheEntry(ctx)};
  
  unsigned int idcErrCont_set_number =  idcErrCont->numberSet();
 
  if (cacheEntry->m_set_number == idcErrCont_set_number){
    ATH_MSG_VERBOSE("Same set number found, skip the next steps.");
    return StatusCode::SUCCESS;
  }else{
    cacheEntry->m_set_number = idcErrCont_set_number; //update the set number in cacheEntry.
  }

  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool size of error container is " << idcErrCont->maxSize());
  const std::vector<std::pair<size_t, uint64_t>> errorcodesforView{idcErrCont->getAll()};
 
  for (const auto& [ hashId, errCode ] : errorcodesforView) {
 
    Identifier wafer_id{m_sct_id->wafer_id(hashId)};
    Identifier module_id{m_sct_id->module_id(wafer_id)};
    size_t hash = static_cast<size_t>(module_id.get_compact());
    if (errCode == uint64_t{0}) {
      // That means this hashId was decoded but had no error
      // In such case we want to fill the cache also with zero so we do not have to fill the cache again for a given view
      // (see logic in: getErrorCodeWithCacheUpdate)
      // Note: invocation of the [] operator on the map will create missing entry and set the value to default (here 0)
      cacheEntry->abcdErrorChips[ hash ];
      cacheEntry->tempMaskedChips[ hash ];
      continue;
    }
 
 
    ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool filling event cache for module " << module_id << " ec " << errCode);
 
    const int side{m_sct_id->side(m_sct_id->wafer_id(hashId))};
    // Each bit of errCode represents each SCT_ByteStreamErrors for one wafer
    // Multiple bits can be true.
    // Convert errCode to 12 bits of abcdErrorChips and 12 bits of tempMaskedChips for one module (=two wafers).
    IDCInDetBSErrContainer::ErrorCode v_abcdErrorChips{errCode & SCT_ByteStreamErrors::ABCDErrorMask()};
    if (v_abcdErrorChips) {
      v_abcdErrorChips >>= SCT_ByteStreamErrors::ABCDError_Chip0; // bit 0 (5) is for chip 0 (5) for both sides
      v_abcdErrorChips <<= (side*N_CHIPS_PER_SIDE); // bit 0 (6) is for chip 0 on side 0 (1)
      cacheEntry->abcdErrorChips[hash] |= v_abcdErrorChips;
    } else {
      cacheEntry->abcdErrorChips[hash] = 0;
    }
    IDCInDetBSErrContainer::ErrorCode v_tempMaskedChips{errCode & SCT_ByteStreamErrors::TempMaskedChipsMask()};
    if (v_tempMaskedChips) {
      v_tempMaskedChips >>= SCT_ByteStreamErrors::TempMaskedChip0; // bit 0 (5) is for chip 0 (5) for both sides0
      v_tempMaskedChips <<= (side*N_CHIPS_PER_SIDE); // bit 0 (6) is for chip 0 on side 0 (1)
      cacheEntry->tempMaskedChips[hash] |= v_tempMaskedChips;
    } else {
      cacheEntry->tempMaskedChips[hash] = 0;
    }
 
  }
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode SCT_ByteStreamErrorsTool::finalize ( )

overridevirtual

Finalize.

Definition at line 52 of file SCT_ByteStreamErrorsTool.cxx.

                                   {
  return StatusCode::SUCCESS;
}

getCacheEntry()

SCT_ByteStreamErrorsTool::IDCCacheEntry * SCT_ByteStreamErrorsTool::getCacheEntry ( const EventContext & ctx ) const

nodiscardprivate

Return cache for the current event If, for current slot, the cache is outdated it is retrieved from the IDC collection.

If the IDC is missing nullptr is returned.

Definition at line 94 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                            {
  IDCCacheEntry* cacheEntry{m_eventCache.get(ctx)};
  if (cacheEntry->needsUpdate(ctx)) {
    const auto *idcErrContPtr{getContainer(ctx)};
    if (idcErrContPtr == nullptr) { // missing or not, the cache needs to be reset
      cacheEntry->reset(ctx.evt(), nullptr);
    } else {
      cacheEntry->reset(ctx.evt(), idcErrContPtr->cache());
    }
    ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool Cache for the event reset " << cacheEntry->eventId  << " with IDC container" << idcErrContPtr);
  }
  return cacheEntry;
}

getChip()

int SCT_ByteStreamErrorsTool::getChip ( const Identifier & stripId, const EventContext & ctx ) const

private

Definition at line 299 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                          {
  const Identifier waferId{m_sct_id->wafer_id(stripId)};
  const IdentifierHash waferHash{m_sct_id->wafer_hash(waferId)};
  const InDetDD::SiDetectorElement* siElement{getDetectorElement(waferHash, ctx)};
  if (siElement==nullptr) {
    ATH_MSG_DEBUG ("InDetDD::SiDetectorElement is not obtained from stripId " << stripId);
    return -1;
  }
  return SCT::getChip(*m_sct_id, *siElement, stripId);
}

getContainer()

const IDCInDetBSErrContainer * SCT_ByteStreamErrorsTool::getContainer ( const EventContext & ctx ) const

nodiscardprivate

Obtains container form the SG, if it is missing it will complain (hard-coded 3 times per job) and return nullptr.

When running over ESD files without BSErr container stored, don't want to flood the user with error messages. Should just have a bunch of empty sets, and keep quiet.

Definition at line 71 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                  {
  SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont(m_bsIDCErrContainerName, ctx);
  if (not idcErrCont.isValid()) {
    m_nRetrievalFailure++;
    if (m_nRetrievalFailure<=3) {
      ATH_MSG_INFO("SCT_ByteStreamErrorsTool Failed to retrieve BS error container "
                   << m_bsIDCErrContainerName.key()
                   << " from StoreGate.");
      if (m_nRetrievalFailure==3) {
        ATH_MSG_INFO("SCT_ByteStreamErrorsTool This message on retrieval failure of " << m_bsIDCErrContainerName.key() << " is suppressed.");
      }
    }
    return nullptr;
  }
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool IDC Container fetched " << m_bsIDCErrContainerName.key());
  return idcErrCont.cptr();
}

getDetectorElement()

const InDetDD::SiDetectorElement * SCT_ByteStreamErrorsTool::getDetectorElement ( const IdentifierHash & waferHash, const EventContext & ctx ) const

private

Definition at line 480 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                                           {
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey, ctx};
  if (not condData.isValid()) return nullptr;
  return condData->getDetectorElement(waferHash);
}

getDetectorElementStatus()

void SCT_ByteStreamErrorsTool::getDetectorElementStatus ( const EventContext & ctx, InDet::SiDetectorElementStatus & element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > * whandle ) const

overridevirtual

Definition at line 162 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                   {
   std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
 
   const auto *idcCachePtr{getCacheEntry(ctx)};
   if (idcCachePtr == nullptr || !idcCachePtr->IDCCache) {
      ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool No cache! ");
      return;
   }
   if (whandle) {
     ATH_MSG_ERROR("SCT_ByteStreamErrorsTool is not for conditions objects");
     whandle->addDependency (IDetectorElementStatusTool::getInvalidRange());
   }
 
   if (fillData(ctx).isFailure()) {
      return; // @TODO what is the correct way to handle this ?  set status to false for all ?
   }
 
   std::vector<bool> &status = element_status.getElementStatus();
   std::vector<InDet::ChipFlags_t> &chip_status = element_status.getElementChipStatus();
   if (status.empty()) {
      status.resize(idcCachePtr->IDCCache->rawReadAccess().size(),true);
   }
   SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> si_element_list{m_SCTDetEleCollKey, ctx};
   if (not si_element_list.isValid()) {
      std::stringstream msg;
      msg << "Failed to get SCT detector element collection with key " << m_SCTDetEleCollKey.key();
      throw std::runtime_error(msg.str());
   }
   if (whandle) {
     whandle->addDependency (si_element_list);
   }
 
   constexpr InDet::ChipFlags_t all_flags_set = static_cast<InDet::ChipFlags_t>((1ul<<(N_CHIPS_PER_SIDE)) - 1ul);
   static_assert( (1ul<<(N_CHIPS_PER_SIDE*N_SIDES)) - 1ul <= std::numeric_limits<InDet::ChipFlags_t>::max());
   if (chip_status.empty()) {
      chip_status.resize(status.size(), all_flags_set);
   }
   unsigned int element_i=0;
   for ( const auto &val : idcCachePtr->IDCCache->rawReadAccess()) {
      uint64_t error_code = val;
      bool is_bad = error_code & m_badErrorMask;
      status.at(element_i) = status.at(element_i) & not is_bad;
      if ( is_bad ) {
         ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool Bad Error " << error_code  << " for ID " << element_i);
      }
      else {
         IdentifierHash hash(element_i);
         const InDetDD::SiDetectorElement *siElement = si_element_list->getDetectorElement(hash);
         const Identifier wafer_id{m_sct_id->wafer_id(hash)};
         const Identifier module_id{m_sct_id->module_id(wafer_id)};
         size_t modhash =  static_cast<size_t>(module_id.get_compact());
 
         unsigned int badChips{m_config->badChips(module_id, ctx)}; // @todo only call once for all
         unsigned int v_abcdErrorChips{ getValueOrZero( idcCachePtr->abcdErrorChips, modhash) };
         unsigned int v_tempMaskedChips{ getValueOrZero( idcCachePtr->tempMaskedChips, modhash) };
         const int side{m_sct_id->side(wafer_id)};
         bool allChipsBad{true};
         const int chipMax{static_cast<short>(side==0 ? N_CHIPS_PER_SIDE : N_CHIPS_PER_SIDE*N_SIDES)};
         InDet::ChipFlags_t bad_chip_flags = 0; 
         for (int chip{chipMax-N_CHIPS_PER_SIDE}; chip<chipMax; chip++) {
            bool issueABCDError{((v_abcdErrorChips >> chip) & 0x1) != 0};
            bool isBadChip{((badChips >> chip) & 0x1) != 0};
            bool isTempMaskedChip{((v_tempMaskedChips >> chip) & 0x1) != 0};
            bool isBad = (issueABCDError or isBadChip or isTempMaskedChip);
            bad_chip_flags |= static_cast<InDet::ChipFlags_t>(isBad) << SCT::getGeometricalFromPhysicalChipID(side, siElement->swapPhiReadoutDirection(), chip);
            allChipsBad &= isBad;
         }
         status.at(element_i) =  status.at(element_i) & not allChipsBad;
         chip_status.at(element_i) &= (~bad_chip_flags) & all_flags_set;
      }
 
      ++element_i;
   }
}

getErrorCodeWithCacheUpdate()

std::pair< StatusCode, unsigned int > SCT_ByteStreamErrorsTool::getErrorCodeWithCacheUpdate ( const Identifier & id, const EventContext & ctx, std::unordered_map< size_t, unsigned int > & whereExected ) const

private

Method that returns BS Error code from the map passed @rag where-Expected If the information is initially missing, the cache update is triggered.

Definition at line 450 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                                                      {
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool getErrorCodeWithCacheUpdate " << moduleId);
  size_t modhash =  static_cast<size_t>(moduleId.get_compact());
  auto it{whereExected.find(modhash)};
  if (it != whereExected.end()) return std::make_pair(StatusCode::SUCCESS, it->second);
 
  // even if there are no errors for this module at all filled
  // we want the entry of value 0 so we know we walked over it and do not need to invoke filling again
  // and and do not need to do it again
 
  auto *cacheEntry{getCacheEntry(ctx)};
  cacheEntry->abcdErrorChips[modhash] =  0;
  cacheEntry->tempMaskedChips[modhash] = 0;
 
  // the content is missing, look for actual errors
  StatusCode sc{fillData(ctx)};
  if (sc.isFailure()) {
    return std::make_pair(StatusCode::FAILURE, 0);
  }
  // handle situation when the cache does not contain desired datum after the update
  it = whereExected.find(modhash);
  if (it == whereExected.end()) {
    ATH_MSG_ERROR("After fillData in abcdErrorChips, cache does not have an infomation about the " << moduleId);
    ATH_MSG_ERROR("Likely cause is a request for for different region");
    return std::make_pair(StatusCode::FAILURE, 0);
  }
  return std::make_pair(StatusCode::SUCCESS, it->second);
}

getErrorSet()

std::set< IdentifierHash > SCT_ByteStreamErrorsTool::getErrorSet ( int errorType, const EventContext & ctx ) const

overridevirtual

The accessor method that can be used by clients to retrieve a set of IdHashes of wafers with a given type of error.

e.g. for monitoring plots.

Definition at line 318 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                  {
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool getErrorSet " << errorType);
  std::set<IdentifierHash> result;
  if (errorType>=0 and errorType<SCT_ByteStreamErrors::NUM_ERROR_TYPES) {
    const auto *idcErrCont{getContainer(ctx)};
    if (idcErrCont != nullptr) {
      const std::set<size_t>& Mask = idcErrCont->getMask();
      const auto& raw = idcErrCont->wholeEventReadAccess();
      for (const size_t hashId : Mask) {
        auto errCode = raw[hashId].load(std::memory_order_relaxed);
        if (SCT_ByteStreamErrors::hasError(errCode, static_cast<SCT_ByteStreamErrors::ErrorType>(errorType))) {
          result.insert(hashId);
        }
      }
    }
  }
  return result;
}

initialize()

StatusCode SCT_ByteStreamErrorsTool::initialize ( )

overridevirtual

Initialize.

Definition at line 30 of file SCT_ByteStreamErrorsTool.cxx.

                                     {
  ATH_CHECK(detStore()->retrieve(m_sct_id, "SCT_ID"));
  m_cntx_sct = m_sct_id->wafer_context();
 
  ATH_CHECK(m_config.retrieve());
 
  // Read (Cond)Handle Keys
  ATH_CHECK(m_bsIDCErrContainerName.initialize());
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
  m_badErrorMask=0;
  for (auto badError : SCT_ByteStreamErrors::BadErrors) {
     if (badError>=63) {
        ATH_MSG_FATAL("Logic error: Error code too large and cannot represented as a bit.");
     }
     m_badErrorMask |= SCT_ByteStreamErrors::makeError(badError);
  }
 
  return StatusCode::SUCCESS;
}

isGood() [1/2]

bool SCT_ByteStreamErrorsTool::isGood ( const Identifier & elementId, const EventContext & ctx, InDetConditions::Hierarchy h = InDetConditions::DEFAULT ) const

overridevirtual

Is the detector element good?

Definition at line 240 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                       {
  if (not canReportAbout(h)) return true;
 
  if (h==InDetConditions::SCT_SIDE) {
    const IdentifierHash elementIdHash{m_sct_id->wafer_hash(elementId)};
    return isGood(elementIdHash, ctx);
  }
  if (h==InDetConditions::SCT_CHIP) {
    return isGoodChip(elementId, ctx);
  }
 
  return true;
}

isGood() [2/2]

bool SCT_ByteStreamErrorsTool::isGood ( const IdentifierHash & elementIdHash, const EventContext & ctx ) const

overridevirtual

this is the principle method which can be accessed via the ConditionsSummaryTool to decide if a wafer is good - in this case we want to return false if the wafer has an error that would result in bad hits or no hits for that event

Definition at line 113 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                   {
  {
 
    std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
    ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool isGood called for " << elementIdHash);
    const auto *idcCachePtr{getCacheEntry(ctx)->IDCCache};
    if (idcCachePtr == nullptr) {
      ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool No cache! ");
      return true;
    }
 
    auto errorCode{idcCachePtr->retrieve(elementIdHash)};
 
    bool is_bad = errorCode & m_badErrorMask;
    if (is_bad) {
      ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool Bad Error " << errorCode  << " for ID " << elementIdHash);
      return false;
    }
 
  } // end of cache operations protection via m_cacheMutex, following code has own protection
  
  // If all 6 chips of a link issue ABCD errors or are bad chips or temporarily masked chips, the link is treated as bad one. 
  const Identifier wafer_id{m_sct_id->wafer_id(elementIdHash)};
  const Identifier module_id{m_sct_id->module_id(wafer_id)};
  unsigned int badChips{m_config->badChips(module_id, ctx)};
  unsigned int v_abcdErrorChips{abcdErrorChips(module_id, ctx)};
  unsigned int v_tempMaskedChips{tempMaskedChips(module_id, ctx)};
  const int side{m_sct_id->side(wafer_id)};
  bool allChipsBad{true};
  const int chipMax{static_cast<short>(side==0 ? N_CHIPS_PER_SIDE : N_CHIPS_PER_SIDE*N_SIDES)};
  for (int chip{chipMax-N_CHIPS_PER_SIDE}; chip<chipMax; chip++) {
    bool issueABCDError{((v_abcdErrorChips >> chip) & 0x1) != 0};
    bool isBadChip{((badChips >> chip) & 0x1) != 0};
    bool isTempMaskedChip{((v_tempMaskedChips >> chip) & 0x1) != 0};
    allChipsBad = (issueABCDError or isBadChip or isTempMaskedChip);
    if (not allChipsBad) break;
  }
  return !allChipsBad;
}

isGoodChip()

bool SCT_ByteStreamErrorsTool::isGoodChip ( const Identifier & stripId, const EventContext & ctx ) const

private

Definition at line 255 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                             {
  // This check assumes present SCT.
  // Get module number
  const Identifier moduleId{m_sct_id->module_id(stripId)};
  if (not moduleId.is_valid()) {
    ATH_MSG_WARNING("moduleId obtained from stripId " << stripId << " is invalid.");
    return false;
  }
 
  // tempMaskedChips and abcdErrorChips hold 12 bits.
  // bit 0 (LSB) is chip 0 for side 0.
  // bit 5 is chip 5 for side 0.
  // bit 6 is chip 6 for side 1.
  // bit 11 is chip 11 for side 1.
  // Temporarily masked chip information
  const unsigned int v_tempMaskedChips{tempMaskedChips(moduleId, ctx)};
  // Information of chips with ABCD errors
  const unsigned int v_abcdErrorChips{abcdErrorChips(moduleId, ctx)};
  // Take 'OR' of tempMaskedChips and abcdErrorChips
  const unsigned int badChips{v_tempMaskedChips | v_abcdErrorChips};
 
  // If there is no bad chip, this check is done.
  if (badChips==0) return true;
 
  const int side{m_sct_id->side(stripId)};
  // Check the six chips on the side
  // 0x3F  = 0000 0011 1111
  // 0xFC0 = 1111 1100 0000
  // If there is no bad chip on the side, this check is done.
  if ((side==0 and (badChips & 0x3F)==0) or (side==1 and (badChips & 0xFC0)==0)) return true;
 
  int chip{getChip(stripId, ctx)};
  if (chip<0 or chip>=12) {
    ATH_MSG_WARNING("chip number is invalid: " << chip);
    return false;
  }
 
  // Check if the chip is bad
  const bool badChip{static_cast<bool>(badChips & (1<<chip))};
 
  return (not badChip);
}

tempMaskedChips()

unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips ( const Identifier & moduleId, const EventContext & ctx ) const

overridevirtual

Definition at line 416 of file SCT_ByteStreamErrorsTool.cxx.

                                                                                                                {
  ATH_MSG_VERBOSE("SCT_ByteStreamErrorsTool tempMaskedChips");
  std::scoped_lock<std::mutex> lock{*m_cacheMutex.get(ctx)};
  auto *cacheEntry{getCacheEntry(ctx)};
  if (cacheEntry->IDCCache == nullptr) {
    ATH_MSG_VERBOSE("cacheEntry->IDCCache == nullptr");
    return 0;
  }
 
  auto [status, v_tempMaskedChips] = getErrorCodeWithCacheUpdate(moduleId, ctx, cacheEntry->tempMaskedChips);
  if (status.isFailure()) {
    ATH_MSG_ERROR("SCT_ByteStreamErrorsTool Failure getting temp masked chip errors");
  }
  return v_tempMaskedChips; // 12 bits are used.
  // Bit 0 is for chip 0 on side 0, bit 1 is for chip 1 on side 0, ..., and bit 11 is for chip 5 on side 1
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

SG::SlotSpecificObj<IDCCacheEntry> m_eventCache SCT_ByteStreamErrorsTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 131 of file SCT_ByteStreamErrorsTool.h.

ATLAS_THREAD_SAFE [2/2]

SG::SlotSpecificObj<std::mutex> m_cacheMutex SCT_ByteStreamErrorsTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 102 of file SCT_ByteStreamErrorsTool.h.

m_badErrorMask

uint64_t SCT_ByteStreamErrorsTool::m_badErrorMask {}

private

Definition at line 100 of file SCT_ByteStreamErrorsTool.h.

{};

m_bsIDCErrContainerName

SG::ReadHandleKey<IDCInDetBSErrContainer> SCT_ByteStreamErrorsTool::m_bsIDCErrContainerName {this, "IDCByteStreamErrContainer", "SCT_ByteStreamErrs", "SCT BS error key for IDC variant"}

private

Definition at line 95 of file SCT_ByteStreamErrorsTool.h.

{this, "IDCByteStreamErrContainer", "SCT_ByteStreamErrs", "SCT BS error key for IDC variant"};

m_cntx_sct

IdContext SCT_ByteStreamErrorsTool::m_cntx_sct

private

Definition at line 99 of file SCT_ByteStreamErrorsTool.h.

m_config

ToolHandle<ISCT_ConfigurationConditionsTool> SCT_ByteStreamErrorsTool::m_config

private

Initial value:

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

Definition at line 92 of file SCT_ByteStreamErrorsTool.h.

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

m_nRetrievalFailure

std::atomic_uint SCT_ByteStreamErrorsTool::m_nRetrievalFailure {0}

mutableprivate

Definition at line 137 of file SCT_ByteStreamErrorsTool.h.

{0};

m_sct_id

const SCT_ID* SCT_ByteStreamErrorsTool::m_sct_id {nullptr}

private

Definition at line 98 of file SCT_ByteStreamErrorsTool.h.

{nullptr};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SCT_ByteStreamErrorsTool::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 96 of file SCT_ByteStreamErrorsTool.h.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

---

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

• SCT_ByteStreamErrorsTool.h
• SCT_ByteStreamErrorsTool.cxx