SCT_ConfigurationConditionsTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "SCT_ConfigurationConditionsTool.h"
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
#include "SCT_ReadoutGeometry/SCT_DetectorElementStatus.h"
 
// Athena includes
#include "InDetIdentifier/SCT_ID.h"
#include "InDetReadoutGeometry/SiDetectorElement.h"
#include "SCT_ReadoutGeometry/SCT_ChipUtils.h"
#include "StoreGate/ReadCondHandle.h"
#include <type_traits>
#include <limits>
 
// Constructor
SCT_ConfigurationConditionsTool::SCT_ConfigurationConditionsTool(const std::string& type, const std::string& name, const IInterface* parent) :
  base_class(type, name, parent)
{ 
}
 
// Initialize
StatusCode SCT_ConfigurationConditionsTool::initialize() {
  ATH_MSG_DEBUG("Initializing configuration");
 
  ATH_CHECK(detStore()->retrieve(m_pHelper, "SCT_ID"));
 
  // Read Cond Handle Key
  ATH_CHECK(m_condKey.initialize());
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  return StatusCode::SUCCESS;
}
 
// What level of element can this service report about
bool SCT_ConfigurationConditionsTool::canReportAbout(InDetConditions::Hierarchy h) const {
  return (h == InDetConditions::SCT_STRIP or
          h == InDetConditions::SCT_CHIP or
          h == InDetConditions::SCT_SIDE or
          h == InDetConditions::SCT_MODULE or
          h == InDetConditions::DEFAULT);
}
 
// Is an element with this Identifier and hierachy good?
bool SCT_ConfigurationConditionsTool::isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
  if (not canReportAbout(h)) return true;
 
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In isGood, SCT_ConfigurationCondData pointer cannot be retrieved");
    return false;
  }
 
  bool result{true};
  if (h == InDetConditions::SCT_STRIP) {
    result = (not condData->isBadStrip(m_pHelper->wafer_hash(m_pHelper->wafer_id(elementId)),
                                       m_pHelper->strip(elementId)));
    // If strip itself is not bad, check if it's in a bad module
    if (result and m_checkStripsInsideModules) result = (not isStripInBadModule(elementId, condData));
  } else if (h == InDetConditions::SCT_MODULE) {
    result = (not condData->isBadModuleId(elementId));
  } else if (h == InDetConditions::SCT_SIDE or h == InDetConditions::DEFAULT) {
    result = (not condData->isBadWaferId(elementId));
  } else if (h == InDetConditions::SCT_CHIP) {
    result = isGoodChip(elementId, ctx);
  }
  return result;
}
 
 
void SCT_ConfigurationConditionsTool::getDetectorElementStatus(const EventContext& ctx, InDet::SiDetectorElementStatus &element_status,
                                                               SG::WriteCondHandle<InDet::SiDetectorElementStatus>* whandle) const {
  SG::ReadCondHandle<SCT_ConfigurationCondData> condDataHandle{m_condKey, ctx};
  if (not condDataHandle.isValid() ) {
     ATH_MSG_ERROR("Invalid cond data handle " << m_condKey.key());
     return;
  }
  if (whandle) {
    whandle->addDependency (condDataHandle);
  }
  const SCT_ConfigurationCondData* condData{ condDataHandle.cptr() };
  const std::set<Identifier>* bad_wafers = condData->getBadWaferIds();
  if (bad_wafers) {
     std::vector<bool> &status = element_status.getElementStatus();
     std::vector<InDet::ChipFlags_t> &chip_status = element_status.getElementChipStatus();
     if (status.empty()) {
        status.resize(m_pHelper->wafer_hash_max(),true);
     }
     constexpr unsigned int N_CHIPS_PER_SIDE = 6;
     constexpr unsigned int N_SIDES = 2;
     constexpr InDet::ChipFlags_t all_flags_set = static_cast<InDet::ChipFlags_t>((1ul<<(N_CHIPS_PER_SIDE*N_SIDES)) - 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);
     }
     for (const Identifier &a_bad_wafer : *bad_wafers) {
        IdentifierHash hash = m_pHelper->wafer_hash(a_bad_wafer);
        status.at(hash.value())=false;
     }
     if (m_checkStripsInsideModules) {
        const std::set<Identifier>* bad_modules = condData->getBadModuleIds();
        if (bad_modules) {
           for (const Identifier &a_bad_module :  *bad_modules) {
              for (unsigned int side_i=0; side_i<N_SIDES; ++side_i) {
                 Identifier wafer_id{m_pHelper->wafer_id(m_pHelper->barrel_ec(a_bad_module),
                                                         m_pHelper->layer_disk(a_bad_module),
                                                         m_pHelper->phi_module(a_bad_module),
                                                         m_pHelper->eta_module(a_bad_module),
                                                         side_i)};
                 IdentifierHash hash = m_pHelper->wafer_hash(wafer_id);
                 chip_status.at(hash.value()) = 0;
              }
           }
        }
     }
     if (condData->getBadChips()) {
        std::array<unsigned int,N_SIDES> side_mask{0x3F, 0xFC0};
        for (const std::pair<const Identifier, unsigned int> &a_bad_module :  *(condData->getBadChips()) ) {
           for (unsigned int side_i=0; side_i<N_SIDES; ++side_i) {
              if (a_bad_module.second & side_mask[side_i]) {
                 Identifier wafer_id{m_pHelper->wafer_id(m_pHelper->barrel_ec(a_bad_module.first),
                                                         m_pHelper->layer_disk(a_bad_module.first),
                                                         m_pHelper->phi_module(a_bad_module.first),
                                                         m_pHelper->eta_module(a_bad_module.first),
                                                         side_i)};
                 IdentifierHash hash = m_pHelper->wafer_hash(wafer_id);
                 unsigned int bad_chip_flags = SCT::getGeometricalFromPhysicalChipFlags(*m_pHelper, *element_status.getDetectorElement(hash),a_bad_module.second );
                 chip_status.at(hash.value()) &= static_cast<InDet::ChipFlags_t>( ~(bad_chip_flags) );
              }
           }
        }
     }
     if (condData->getBadStripIds()) {
        std::vector<std::vector<unsigned short> > &bad_strips = element_status.getBadCells();
        if (bad_strips.empty()) {
           bad_strips.resize(status.size());
        }
        for (const Identifier &bad_strip :  *(condData->getBadStripIds()) ) {
           IdentifierHash hash = m_pHelper->wafer_hash(m_pHelper->wafer_id(bad_strip));
           // skip bad modules and chips
           if (!status.at(hash)) continue;
           int strip_i = m_pHelper->strip(bad_strip);
 
           std::vector<unsigned short> &bad_module_strips_combined = bad_strips.at(hash);
           std::vector<unsigned short>::const_iterator iter = std::lower_bound(bad_module_strips_combined.begin(),bad_module_strips_combined.end(),strip_i);
           if (iter == bad_module_strips_combined.end() || *iter != strip_i) {
              bad_module_strips_combined.insert( iter, strip_i);
           }
        }
     }
  }
}
 
// Is a wafer with this IdentifierHash good?
bool SCT_ConfigurationConditionsTool::isGood(const IdentifierHash& hashId, const EventContext& ctx) const {
  const Identifier elementId{m_pHelper->wafer_id(hashId)};
  return isGood(elementId, ctx, InDetConditions::SCT_SIDE);
}
 
// Is a chip with this Identifier good?
bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId, const EventContext& ctx) const {
  // This check assumes present SCT.
  // Get module number
  const Identifier moduleId{m_pHelper->module_id(stripId)};
  if (not moduleId.is_valid()) {
    ATH_MSG_WARNING("moduleId obtained from stripId " << stripId << " is invalid.");
    return false;
  }
 
  // badChips word for the module
  const unsigned int v_badChips{badChips(moduleId, ctx)};
  // badChips holds 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.
 
  // If there is no bad chip, this check is done.
  if (v_badChips==0) return true;
 
  const int side{m_pHelper->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 (v_badChips & 0x3F)==0) or (side==1 and (v_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>(v_badChips & (1<<chip))};
 
  return (not badChip);
}
 
// Check if a strip is within a bad module
bool SCT_ConfigurationConditionsTool::isStripInBadModule(const Identifier& stripId, const SCT_ConfigurationCondData* condData) const {
  if (condData==nullptr) {
    ATH_MSG_ERROR("In isStripInBadModule, SCT_ConfigurationCondData pointer cannot be retrieved");
    return true;
  }
 
  const Identifier moduleId(m_pHelper->module_id(m_pHelper->wafer_id(stripId)));
  return condData->isBadModuleId(moduleId);
}
 
// Check if a wafer is within a bad module
bool SCT_ConfigurationConditionsTool::isWaferInBadModule(const Identifier& waferId, const EventContext& ctx) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In isWaferInBadModule, SCT_ConfigurationCondData pointer cannot be retrieved");
    return true;
  }
 
  const Identifier moduleId{m_pHelper->module_id(waferId)};
  return condData->isBadModuleId(moduleId);
}
 
// Find the chip number containing a particular strip Identifier
int SCT_ConfigurationConditionsTool::getChip(const Identifier& stripId, const EventContext& ctx) const {
  // Check for swapped readout direction
  const IdentifierHash waferHash{m_pHelper->wafer_hash(m_pHelper->wafer_id(stripId))};
  const InDetDD::SiDetectorElement* pElement{getDetectorElement(waferHash, ctx)};
  if (pElement==nullptr) {
    ATH_MSG_FATAL("Element pointer is nullptr in 'badStrips' method");
    return invalidChipNumber;
  }
  return SCT::getChip(*m_pHelper, *pElement, stripId);
}
 
const std::set<Identifier>* SCT_ConfigurationConditionsTool::badModules(const EventContext& ctx) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badModules, SCT_ConfigurationCondData pointer cannot be retrieved");
    return nullptr;
  }
 
  return condData->getBadModuleIds();
}
 
void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules, bool ignoreBadChips) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badStrips, SCT_ConfigurationCondData pointer cannot be retrieved");
    return;
  }
 
  // Bad strips for a given module
  if (ignoreBadModules) {
    // Ignore strips in bad modules
    if (condData->isBadModuleId(moduleId)) return;
  }
 
  for (const Identifier& badStripId: *(condData->getBadStripIds())) {
    if (ignoreBadChips) {
      // Ignore strips in bad chips
      const int chip{getChip(badStripId, ctx)};
      if (chip!=invalidChipNumber) {
        unsigned int chipStatusWord{condData->getBadChips(moduleId)};
        if ((chipStatusWord & (1 << chip)) != 0) continue;
      }   
    }
    if (m_pHelper->module_id(m_pHelper->wafer_id(badStripId)) == moduleId) strips.insert(badStripId);
  }
}
 
std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const IdentifierHash& hash, const EventContext& ctx) const {
  // Bad links for a given module
  // Bad convetion is used. true is for good link and false is for bad link...
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badLinks, SCT_ConfigurationCondData pointer cannot be retrieved");
    return std::pair<bool, bool>{false, false};
  }
 
  return condData->areBadLinks(hash);
}
 
const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks(const EventContext& ctx) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badLinks, SCT_ConfigurationCondData pointer cannot be retrieved");
    return nullptr;
  }
 
  return condData->getBadLinks();
}
 
const std::map<Identifier, unsigned int>* SCT_ConfigurationConditionsTool::badChips(const EventContext& ctx) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badChips, SCT_ConfigurationCondData pointer cannot be retrieved");
    return nullptr;
  }
 
  return condData->getBadChips();
}
 
unsigned int SCT_ConfigurationConditionsTool::badChips(const Identifier& moduleId, const EventContext& ctx) const {
  // Bad chips for a given module
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badChips, SCT_ConfigurationCondData pointer cannot be retrieved");
    return 0xFFF; // 12 bad chips
  }
 
  return condData->getBadChips(moduleId);
}
 
void
SCT_ConfigurationConditionsTool::badStrips(std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules, bool ignoreBadChips) const {
  const SCT_ConfigurationCondData* condData{getCondData(ctx)};
  if (condData==nullptr) {
    ATH_MSG_ERROR("In badStrips, SCT_ConfigurationCondData pointer cannot be retrieved");
    return;
  }
 
  if (!ignoreBadModules and !ignoreBadChips) {
    const std::set<Identifier>& bad_strips = *condData->getBadStripIds();
    std::copy(bad_strips.begin(), bad_strips.end(), std::inserter(strips,strips.begin()));
    return;
  }
  for (const Identifier& badStripId: *(condData->getBadStripIds())) {
    const Identifier moduleId{m_pHelper->module_id(m_pHelper->wafer_id(badStripId))};
    // Ignore strips in bad modules
    if (ignoreBadModules) {
      if (condData->isBadModuleId(moduleId)) continue;
    }
    // Ignore strips in bad chips
    if (ignoreBadChips) {
      const int chip{getChip(badStripId, ctx)};
      if (chip!=invalidChipNumber) {
        unsigned int chipStatusWord{condData->getBadChips(moduleId)};
        if ((chipStatusWord & (1 << chip)) != 0) continue;
      }
    }
    strips.insert(badStripId);
  }
}
 
const SCT_ConfigurationCondData*
SCT_ConfigurationConditionsTool::getCondData(const EventContext& ctx) const {
  SG::ReadCondHandle<SCT_ConfigurationCondData> condData{m_condKey, ctx};
  return condData.retrieve();
}
 
const InDetDD::SiDetectorElement* SCT_ConfigurationConditionsTool::getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const {
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey, ctx};
  if (not condData.isValid()) return nullptr;
  return condData->getDetectorElement(waferHash);
}