SCT_ConfigurationConditionsTool Class Reference

Service that keeps track of configuration conditions. More...

#include <SCT_ConfigurationConditionsTool.h>

Inheritance diagram for SCT_ConfigurationConditionsTool:

Collaboration diagram for SCT_ConfigurationConditionsTool:

Public Member Functions
	SCT_ConfigurationConditionsTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SCT_ConfigurationConditionsTool ()=default
virtual StatusCode	initialize () override
virtual bool	canReportAbout (InDetConditions::Hierarchy h) const override
	Can the tool report about the given component?
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 &hashId, const EventContext &ctx) const override
	Is it good?
virtual void	getDetectorElementStatus (const EventContext &ctx, InDet::SiDetectorElementStatus &element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override
virtual const std::set< Identifier > *	badModules (const EventContext &ctx) const override
	List of bad modules.
virtual void	badStrips (std::set< Identifier > &strips, const EventContext &ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const override
	List of bad strips.
virtual void	badStrips (const Identifier &moduleId, std::set< Identifier > &strips, const EventContext &ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const override
	List of bad strips for a given module.
virtual std::pair< bool, bool >	badLinks (const IdentifierHash &hash, const EventContext &ctx) const override
	List of bad links.
virtual const std::map< IdentifierHash, std::pair< bool, bool > > *	badLinks (const EventContext &ctx) const override
	Bad links for a given module.
virtual const std::map< Identifier, unsigned int > *	badChips (const EventContext &ctx) const override
	List of bad chips.
virtual unsigned int	badChips (const Identifier &moduleId, const EventContext &ctx) const override
	Bad chips for a given module.
virtual int	getChip (const Identifier &stripId, const EventContext &ctx) const override
	Get the chip number containing a particular strip.

Private Types
enum	{ stripsPerChip =128 , lastStrip =767 , invalidChipNumber =-1 }
	enum for constants More...

Private Member Functions
bool	isStripInBadModule (const Identifier &stripId, const SCT_ConfigurationCondData *) const
	Is a strip within a bad module.
bool	isWaferInBadModule (const Identifier &waferId, const EventContext &ctx) const
	Is a wafer in a bad module.
bool	isGoodChip (const Identifier &stripId, const EventContext &ctx) const
	Is a chip with this Identifier good?
const SCT_ConfigurationCondData *	getCondData (const EventContext &ctx) const
const InDetDD::SiDetectorElement *	getDetectorElement (const IdentifierHash &waferHash, const EventContext &ctx) const

Private Attributes
SG::ReadCondHandleKey< SCT_ConfigurationCondData >	m_condKey {this, "CondKey", "SCT_ConfigurationCondData", "SCT DAQ configuration"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
const SCT_ID *	m_pHelper {nullptr}
	ID helper for SCT.
BooleanProperty	m_checkStripsInsideModules {this, "checkStripsInsideModule", true, " Do we want to check if a strip is bad because it is inside a bad module"}

Detailed Description

Service that keeps track of configuration conditions.

Tool which reads SCT_Configuration from the database Deals with bad modules, bad links, strips out of the readout and bad strips.

Definition at line 41 of file SCT_ConfigurationConditionsTool.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

enum for constants

Enumerator
stripsPerChip
lastStrip
invalidChipNumber

Definition at line 96 of file SCT_ConfigurationConditionsTool.h.

{stripsPerChip=128, lastStrip=767, invalidChipNumber=-1};

Constructor & Destructor Documentation

SCT_ConfigurationConditionsTool()

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

Definition at line 18 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                                       :
  base_class(type, name, parent)
{ 
}

~SCT_ConfigurationConditionsTool()

virtual SCT_ConfigurationConditionsTool::~SCT_ConfigurationConditionsTool ( )

virtualdefault

Member Function Documentation

badChips() [1/2]

const std::map< Identifier, unsigned int > * SCT_ConfigurationConditionsTool::badChips ( const EventContext & ctx ) const

overridevirtual

List of bad chips.

Definition at line 294 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                               {
  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();
}

badChips() [2/2]

unsigned int SCT_ConfigurationConditionsTool::badChips ( const Identifier & moduleId, const EventContext & ctx ) const

overridevirtual

Bad chips for a given module.

Definition at line 304 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                {
  // 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);
}

badLinks() [1/2]

const std::map< IdentifierHash, std::pair< bool, bool > > * SCT_ConfigurationConditionsTool::badLinks ( const EventContext & ctx ) const

overridevirtual

Bad links for a given module.

Definition at line 284 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                          {
  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();
}

badLinks() [2/2]

std::pair< bool, bool > SCT_ConfigurationConditionsTool::badLinks ( const IdentifierHash & hash, const EventContext & ctx ) const

overridevirtual

List of bad links.

Definition at line 272 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                       {
  // 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);
}

badModules()

const std::set< Identifier > * SCT_ConfigurationConditionsTool::badModules ( const EventContext & ctx ) const

overridevirtual

List of bad modules.

Definition at line 236 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                   {
  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();
}

badStrips() [1/2]

void SCT_ConfigurationConditionsTool::badStrips ( const Identifier & moduleId, std::set< Identifier > & strips, const EventContext & ctx, bool ignoreBadModules = false, bool ignoreBadChips = false ) const

overridevirtual

List of bad strips for a given module.

Definition at line 246 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                                                                                 {
  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);
  }
}

badStrips() [2/2]

void SCT_ConfigurationConditionsTool::badStrips ( std::set< Identifier > & strips, const EventContext & ctx, bool ignoreBadModules = false, bool ignoreBadChips = false ) const

overridevirtual

List of bad strips.

Definition at line 316 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                                                {
  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);
  }
}

canReportAbout()

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

overridevirtual

Can the tool report about the given component?

(chip, module...)

Definition at line 37 of file SCT_ConfigurationConditionsTool.cxx.

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

getChip()

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

overridevirtual

Get the chip number containing a particular strip.

Definition at line 225 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                     {
  // 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);
}

getCondData()

const SCT_ConfigurationCondData * SCT_ConfigurationConditionsTool::getCondData ( const EventContext & ctx ) const

private

Definition at line 347 of file SCT_ConfigurationConditionsTool.cxx.

                                                                          {
  SG::ReadCondHandle<SCT_ConfigurationCondData> condData{m_condKey, ctx};
  return condData.retrieve();
}

getDetectorElement()

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

private

Definition at line 352 of file SCT_ConfigurationConditionsTool.cxx.

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

getDetectorElementStatus()

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

overridevirtual

Definition at line 72 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                               {
  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);
           }
        }
     }
  }
}

initialize()

StatusCode SCT_ConfigurationConditionsTool::initialize ( )

overridevirtual

Definition at line 24 of file SCT_ConfigurationConditionsTool.cxx.

                                                       {
  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;
}

isGood() [1/2]

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

overridevirtual

Is the detector element good?

Definition at line 46 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                                   {
  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;
}

isGood() [2/2]

bool SCT_ConfigurationConditionsTool::isGood ( const IdentifierHash & hashId, const EventContext & ctx ) const

overridevirtual

Is it good?

, using wafer hash

Definition at line 156 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                        {
  const Identifier elementId{m_pHelper->wafer_id(hashId)};
  return isGood(elementId, ctx, InDetConditions::SCT_SIDE);
}

isGoodChip()

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

private

Is a chip with this Identifier good?

Definition at line 162 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                         {
  // 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);
}

isStripInBadModule()

bool SCT_ConfigurationConditionsTool::isStripInBadModule ( const Identifier & stripId, const SCT_ConfigurationCondData * condData ) const

private

Is a strip within a bad module.

Definition at line 202 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                                   {
  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);
}

isWaferInBadModule()

bool SCT_ConfigurationConditionsTool::isWaferInBadModule ( const Identifier & waferId, const EventContext & ctx ) const

private

Is a wafer in a bad module.

Definition at line 213 of file SCT_ConfigurationConditionsTool.cxx.

                                                                                                                 {
  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);
}

Member Data Documentation

m_checkStripsInsideModules

BooleanProperty SCT_ConfigurationConditionsTool::m_checkStripsInsideModules {this, "checkStripsInsideModule", true, " Do we want to check if a strip is bad because it is inside a bad module"}

private

Definition at line 85 of file SCT_ConfigurationConditionsTool.h.

{this, "checkStripsInsideModule", true, " Do we want to check if a strip is bad because it is inside a bad module"};

m_condKey

SG::ReadCondHandleKey<SCT_ConfigurationCondData> SCT_ConfigurationConditionsTool::m_condKey {this, "CondKey", "SCT_ConfigurationCondData", "SCT DAQ configuration"}

private

Definition at line 81 of file SCT_ConfigurationConditionsTool.h.

{this, "CondKey", "SCT_ConfigurationCondData", "SCT DAQ configuration"};

m_pHelper

const SCT_ID* SCT_ConfigurationConditionsTool::m_pHelper {nullptr}

private

ID helper for SCT.

Definition at line 84 of file SCT_ConfigurationConditionsTool.h.

{nullptr};                  

m_SCTDetEleCollKey

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

private

Definition at line 82 of file SCT_ConfigurationConditionsTool.h.

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

---

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

• SCT_ConfigurationConditionsTool.h
• SCT_ConfigurationConditionsTool.cxx