SCT_MonitorConditionsTool Class Reference

Class for keeping track of errors caught by the monitoring. More...

#include <SCT_MonitorConditionsTool.h>

Inheritance diagram for SCT_MonitorConditionsTool:

Collaboration diagram for SCT_MonitorConditionsTool:

Public Member Functions
	SCT_MonitorConditionsTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SCT_MonitorConditionsTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual bool	canReportAbout (InDetConditions::Hierarchy h) const override
	Can the service report about the given component? (chip, module...).
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?, using wafer hash
virtual void	getDetectorElementStatus (const EventContext &ctx, InDet::SiDetectorElementStatus &element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override
virtual void	badStrips (std::set< Identifier > &strips, const EventContext &ctx) const override
	List of bad strip Identifiers.
virtual void	badStrips (const Identifier &moduleId, std::set< Identifier > &strips, const EventContext &ctx) const override
	List of bad strip Identifiers for a given module.
virtual std::string	badStripsAsString (const Identifier &moduleId, const EventContext &ctx) const override
	String of bad strip numbers for a given module.

Private Member Functions
std::string	getList (const Identifier &imodule, const EventContext &ctx) const
const SCT_MonitorCondData *	getCondData (const EventContext &ctx) const

Static Private Member Functions
static void	expandRange (const std::string &rangeStr, std::set< int > &rangeList)
static void	expandList (const std::string &defectStr, std::set< int > &defectList)

Private Attributes
UnsignedIntegerProperty	m_nhits_noisychip {this, "Nnoisychip", 64}
UnsignedIntegerProperty	m_nhits_noisywafer {this, "Nnoisywafer", 384}
UnsignedIntegerProperty	m_nhits_noisymodule {this, "Nnoisycmodule", 768}
const SCT_ID *	m_pHelper {nullptr}
SG::ReadCondHandleKey< SCT_MonitorCondData >	m_condKey {this, "CondKey", "SCT_MonitorCondData", "SCT noisy strips"}

Static Private Attributes
static const std::string	s_separator {"-"}

Detailed Description

Class for keeping track of errors caught by the monitoring.

Definition at line 32 of file SCT_MonitorConditionsTool.h.

Constructor & Destructor Documentation

SCT_MonitorConditionsTool()

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

Definition at line 41 of file SCT_MonitorConditionsTool.cxx.

                                                                                                                          :
  base_class(type, name, parent)
{
}

~SCT_MonitorConditionsTool()

virtual SCT_MonitorConditionsTool::~SCT_MonitorConditionsTool ( )

virtualdefault

Member Function Documentation

badStrips() [1/2]

void SCT_MonitorConditionsTool::badStrips ( const Identifier & moduleId, std::set< Identifier > & strips, const EventContext & ctx ) const

overridevirtual

List of bad strip Identifiers for a given module.

Definition at line 207 of file SCT_MonitorConditionsTool.cxx.

                                                                                                                          {
  // Set of bad strip Identifers for a given module
  // Get defect string and check it is sensible, i.e. non-empty and contains numbers
  std::string defectStr{getList(moduleId, ctx)};
  if (doesNotHaveNumbers(defectStr)) return;
 
  // Expand the string
  std::set<int> defectList;
  expandList(defectStr, defectList);
 
  // Convert strip number to Identifier and add to list
  std::set<int>::const_iterator defectItr{defectList.begin()}, defectEnd{defectList.end()};
  for (; defectItr!=defectEnd; ++defectItr) {
    // Strips in the DB are numbered 0-767 (side 0) and 768-1535 (side 1).  
    // This is different from the usual online/offline numbering schemes
    int side{(*defectItr) > SCT_ConditionsData::STRIPS_PER_WAFER-1 ? 1 : 0};
    int stripNum{side==1 ? (*defectItr) - SCT_ConditionsData::STRIPS_PER_WAFER : (*defectItr)};
   
    Identifier stripId{m_pHelper->strip_id(m_pHelper->barrel_ec(moduleId),  m_pHelper->layer_disk(moduleId),
                                           m_pHelper->phi_module(moduleId), m_pHelper->eta_module(moduleId),
                                           side, stripNum)};
 
    ATH_MSG_DEBUG("Bad Strip: Strip number in DB = " << *defectItr<< ", side/offline strip number = " << side << "/" << stripNum<< ", Identifier = " << stripId);
 
    strips.insert(stripId);
  }
}

badStrips() [2/2]

void SCT_MonitorConditionsTool::badStrips ( std::set< Identifier > & strips, const EventContext & ctx ) const

overridevirtual

List of bad strip Identifiers.

Definition at line 193 of file SCT_MonitorConditionsTool.cxx.

                                                                                              {
  // Set of bad strip Identifers for all modules
  SCT_ID::const_id_iterator waferItr{m_pHelper->wafer_begin()}, waferEnd{m_pHelper->wafer_end()};
  // Loop over modules (side-0 of wafers)
  for (; waferItr != waferEnd; ++waferItr) {
    if (m_pHelper->side(*waferItr) != 0) continue;
    Identifier moduleId{m_pHelper->module_id(*waferItr)};
    badStrips(moduleId, strips, ctx);
  }
}

badStripsAsString()

std::string SCT_MonitorConditionsTool::badStripsAsString ( const Identifier & moduleId, const EventContext & ctx ) const

overridevirtual

String of bad strip numbers for a given module.

Definition at line 238 of file SCT_MonitorConditionsTool.cxx.

                                                                                                      {
  return getList(moduleId, ctx);
}

canReportAbout()

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

overridevirtual

Can the service report about the given component? (chip, module...).

Definition at line 71 of file SCT_MonitorConditionsTool.cxx.

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

expandList()

void SCT_MonitorConditionsTool::expandList ( const std::string & defectStr, std::set< int > & defectList )

staticprivate

Definition at line 283 of file SCT_MonitorConditionsTool.cxx.

                                                                                         {
  // Expand a given defect list
 
  // Empty list or one without numbers
  if (doesNotHaveNumbers(defectStr)) return;
 
  std::istringstream is{defectStr};
  std::istream_iterator<std::string> defectItr{is};
  std::istream_iterator<std::string> defectEnd;     //relies on default constructor to produce eof
 
  // Loop over (space-seperated) defects and add to list
  for (; defectItr != defectEnd; ++defectItr) expandRange(*defectItr, defectList);
}

expandRange()

void SCT_MonitorConditionsTool::expandRange ( const std::string & rangeStr, std::set< int > & rangeList )

staticprivate

Definition at line 262 of file SCT_MonitorConditionsTool.cxx.

                                                                                        {
  // Expand a given defect range
  // Find separator
  std::string::size_type sepPos{rangeStr.find(s_separator)};
  // Check if it's a range
  if (sepPos != std::string::npos) {
    // Extract min and max
    std::string::size_type len1{sepPos++}, len2{rangeStr.size()-sepPos};
    int min{std::stoi(rangeStr.substr(0,len1))};
    int max{std::stoi(rangeStr.substr(sepPos,len2))};
    // Add all strips in range to list
    while (min != (max+1)) rangeList.insert(min++);
  } else { 
    // Assume single number
    rangeList.insert(std::stoi(rangeStr));
  }  
}

finalize()

StatusCode SCT_MonitorConditionsTool::finalize ( )

overridevirtual

Definition at line 64 of file SCT_MonitorConditionsTool.cxx.

                                    {
  return StatusCode::SUCCESS;
}

getCondData()

const SCT_MonitorCondData * SCT_MonitorConditionsTool::getCondData ( const EventContext & ctx ) const

private

Definition at line 300 of file SCT_MonitorConditionsTool.cxx.

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

getDetectorElementStatus()

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

overridevirtual

Definition at line 114 of file SCT_MonitorConditionsTool.cxx.

                                                                                                                          {
  SG::ReadCondHandle<SCT_MonitorCondData> condDataHandle{m_condKey, ctx};
  if (not condDataHandle.isValid()) {
     ATH_MSG_ERROR("Invalid cond data handle " << m_condKey.key() );
     return;
  }
  const SCT_MonitorCondData* condData{condDataHandle.cptr() };
  if (whandle) {
    whandle->addDependency (condDataHandle);
  }
  if (condData) {
     std::vector<bool> &status = element_status.getElementStatus();
     if (status.empty()) {
        status.resize(m_pHelper->wafer_hash_max(),true);
     }
     for (unsigned int hash=0; hash<status.size(); ++hash) {
        status.at(hash) = status.at(hash) && not (condData->nBadStripsForWafer(hash)>=m_nhits_noisywafer);
     }
 
     std::vector<InDet::ChipFlags_t> &chip_status = element_status.getElementChipStatus();
     if (chip_status.empty()) {
        constexpr InDet::ChipFlags_t all_chips_set = static_cast<InDet::ChipFlags_t>((1ul<<(SCT::N_CHIPS_PER_SIDE*SCT::N_SIDES)) - 1ul);
        static_assert( (1ul<<(SCT::N_CHIPS_PER_SIDE*SCT::N_SIDES)) - 1ul <= std::numeric_limits<InDet::ChipFlags_t>::max());
        chip_status.resize(m_pHelper->wafer_hash_max(),all_chips_set);
     }
 
     std::vector<std::vector<unsigned short> >  &bad_strips = element_status.getBadCells();
     if (bad_strips.empty()) {
        bad_strips.resize(status.size());
     }
 
     std::vector<std::pair<unsigned int, unsigned int> > tmp_bad_strips;
     for (unsigned int module_hash=0; module_hash<status.size(); ++module_hash) {
        IdentifierHash moduleHash(module_hash);
 
        std::vector<unsigned short> &bad_module_strips_out = bad_strips.at(module_hash);
        std::array<unsigned int, SCT::N_CHIPS_PER_SIDE> bad_strip_counts{};
 
        const std::array<std::bitset<SCT_ConditionsData::STRIPS_PER_CHIP>,
                         SCT_ConditionsData::CHIPS_PER_SIDE>
           &bad_module_strips_in = condData->badStripsForModule(moduleHash);
 
        unsigned int strip_i=0;
        tmp_bad_strips.clear();
        tmp_bad_strips.reserve(bad_module_strips_in.size()*SCT_ConditionsData::STRIPS_PER_CHIP);
 
        for (const auto& chip_i : bad_module_strips_in) {
           unsigned int geoemtrical_chip_id = SCT::getGeometricalChipID(strip_i);
 
           for (unsigned int strip_per_chip_i=0; strip_per_chip_i<chip_i.size(); ++strip_per_chip_i) {
              if (chip_i.test(strip_per_chip_i)) {
                 tmp_bad_strips.emplace_back(geoemtrical_chip_id,strip_i);
                 ++bad_strip_counts.at(geoemtrical_chip_id);
              }
              ++strip_i;
           }
        }
 
        InDet::ChipFlags_t bad_chips=0;
        for (unsigned int the_chip=0; the_chip< bad_strip_counts.size(); ++the_chip) {
           bad_chips |= static_cast<InDet::ChipFlags_t >((bad_strip_counts[the_chip]>=m_nhits_noisychip) << the_chip);
        }
        chip_status[module_hash] &= ~bad_chips;
 
        for (const std::pair<unsigned int, unsigned int> &chip_and_strip : tmp_bad_strips) {
           unsigned int strip_i=chip_and_strip.second;
           std::vector<unsigned short>::const_iterator iter = std::lower_bound(bad_module_strips_out.begin(),bad_module_strips_out.end(),strip_i);
           if (iter == bad_module_strips_out.end() || *iter != strip_i) {
              bad_module_strips_out.insert( iter, strip_i);
           }
        }
     }
  }
}

getList()

std::string SCT_MonitorConditionsTool::getList ( const Identifier & imodule, const EventContext & ctx ) const

private

Definition at line 247 of file SCT_MonitorConditionsTool.cxx.

                                                                                            {
  string currentDefectList{""};
  const SCT_MonitorCondData* condData{getCondData(ctx)};
  if (condData) {
    const IdentifierHash moduleHash{m_pHelper->wafer_hash(moduleId)};
    condData->find(moduleHash, currentDefectList);
  } else {
    ATH_MSG_ERROR("In getList - no data");
  }
  return currentDefectList;
}

initialize()

StatusCode SCT_MonitorConditionsTool::initialize ( )

overridevirtual

Definition at line 49 of file SCT_MonitorConditionsTool.cxx.

                                      {
  if (detStore()->retrieve(m_pHelper,"SCT_ID").isFailure()) {
    ATH_MSG_FATAL("SCT helper failed to retrieve");
    return StatusCode::FAILURE;
  }
 
  // Read Cond Handle Key
  ATH_CHECK(m_condKey.initialize());
 
  return StatusCode::SUCCESS;
}

isGood() [1/2]

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

overridevirtual

Is the detector element good?

Definition at line 79 of file SCT_MonitorConditionsTool.cxx.

                                                                                                                        {
  const Identifier waferId{m_pHelper->wafer_id(elementId)};
  const Identifier moduleId{m_pHelper->module_id(waferId)};
  const IdentifierHash waferHash{m_pHelper->wafer_hash(waferId)};
  const IdentifierHash moduleHash{m_pHelper->wafer_hash(moduleId)};
  const int strip{m_pHelper->strip(elementId)};
 
  const SCT_MonitorCondData* condData{getCondData(ctx)};
  if (condData) {
    switch (h) {
    case InDetConditions::SCT_MODULE:
      return not (condData->nBadStripsForModule(moduleHash)>=m_nhits_noisymodule);
    case InDetConditions::SCT_SIDE:
      return not (condData->nBadStripsForWafer(waferHash)>=m_nhits_noisywafer);
    case InDetConditions::SCT_CHIP:
      return not (condData->nBadStripsForChip(waferHash, strip)>=m_nhits_noisychip);
    case InDetConditions::SCT_STRIP: {
      return not condData->isBadStrip(waferHash, strip);
    }
    default:
      return true;
    }//end of switch statement
  }
 
  return true;
}

isGood() [2/2]

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

overridevirtual

is it good?, using wafer hash

Definition at line 109 of file SCT_MonitorConditionsTool.cxx.

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

Member Data Documentation

m_condKey

SG::ReadCondHandleKey<SCT_MonitorCondData> SCT_MonitorConditionsTool::m_condKey {this, "CondKey", "SCT_MonitorCondData", "SCT noisy strips"}

private

Definition at line 81 of file SCT_MonitorConditionsTool.h.

{this, "CondKey", "SCT_MonitorCondData", "SCT noisy strips"};

m_nhits_noisychip

UnsignedIntegerProperty SCT_MonitorConditionsTool::m_nhits_noisychip {this, "Nnoisychip", 64}

private

Definition at line 76 of file SCT_MonitorConditionsTool.h.

{this, "Nnoisychip", 64};

m_nhits_noisymodule

UnsignedIntegerProperty SCT_MonitorConditionsTool::m_nhits_noisymodule {this, "Nnoisycmodule", 768}

private

Definition at line 78 of file SCT_MonitorConditionsTool.h.

{this, "Nnoisycmodule", 768};

m_nhits_noisywafer

UnsignedIntegerProperty SCT_MonitorConditionsTool::m_nhits_noisywafer {this, "Nnoisywafer", 384}

private

Definition at line 77 of file SCT_MonitorConditionsTool.h.

{this, "Nnoisywafer", 384};

m_pHelper

const SCT_ID* SCT_MonitorConditionsTool::m_pHelper {nullptr}

private

Definition at line 79 of file SCT_MonitorConditionsTool.h.

{nullptr};

s_separator

const string SCT_MonitorConditionsTool::s_separator {"-"}

staticprivate

Definition at line 39 of file SCT_MonitorConditionsTool.h.

---

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

• SCT_MonitorConditionsTool.h
• SCT_MonitorConditionsTool.cxx