SCT_MonitorCondData Class Reference

Class for data object used in SCT_MonitorCondAlg and SCT_MonitorConditionsTool. More...

#include <SCT_MonitorCondData.h>

Collaboration diagram for SCT_MonitorCondData:

Public Member Functions
	SCT_MonitorCondData ()
	Constructor.
virtual	~SCT_MonitorCondData ()=default
	Destructor.
bool	find (const IdentifierHash &hash, std::string &defectList) const
	Check if a module has a defect (a list of bad strips). If it does not have defect return false.
void	insert (const IdentifierHash &hash, const std::string &defectList)
	Insert a new defect (a list of bad strips) for a module.
void	clear ()
	Clear m_defectListArray.
std::size_t	nBadStripsForModule (const IdentifierHash &moduleHash) const
	Get the number of bad strips for a module.
std::size_t	nBadStripsForWafer (const IdentifierHash &waferHash) const
	Get the number of bad strips for a wafer.
std::size_t	nBadStripsForChip (const IdentifierHash &waferHash, const int strip) const
	Get the number of bad strips for the chip, where a strip locates.
bool	isBadStrip (const IdentifierHash &waferHash, const int strip) const
	Check if a strip is bad.
const std::array< std::bitset< SCT_ConditionsData::STRIPS_PER_CHIP >, SCT_ConditionsData::CHIPS_PER_SIDE > &	badStripsForModule (const IdentifierHash &waferHash) const
const std::array< std::array< std::array< std::bitset< SCT_ConditionsData::STRIPS_PER_CHIP >, SCT_ConditionsData::CHIPS_PER_SIDE >, SCT_ConditionsData::SIDES_PER_MODULE >, SCT_ConditionsData::NUMBER_OF_MODULES > &	badStrips () const

Private Member Functions
void	clearModule (const std::size_t moduleIndex)
void	fillBadStrip (const std::size_t moduleIndex, const int strip)

Private Attributes
std::array< std::string, SCT_ConditionsData::NUMBER_OF_MODULES >	m_defectListArray
	Store the relation between modules and defects (lists of bad strips).
std::array< std::array< std::array< std::bitset< SCT_ConditionsData::STRIPS_PER_CHIP >, SCT_ConditionsData::CHIPS_PER_SIDE >, SCT_ConditionsData::SIDES_PER_MODULE >, SCT_ConditionsData::NUMBER_OF_MODULES >	m_badStripArray
std::array< std::array< std::array< std::size_t, SCT_ConditionsData::CHIPS_PER_SIDE >, SCT_ConditionsData::SIDES_PER_MODULE >, SCT_ConditionsData::NUMBER_OF_MODULES >	m_badChipArray {}
std::array< std::array< std::size_t, SCT_ConditionsData::SIDES_PER_MODULE >, SCT_ConditionsData::NUMBER_OF_MODULES >	m_badWaferArray {}
std::array< std::size_t, SCT_ConditionsData::NUMBER_OF_MODULES >	m_badModuleArray {}

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

Detailed Description

Class for data object used in SCT_MonitorCondAlg and SCT_MonitorConditionsTool.

Definition at line 29 of file SCT_MonitorCondData.h.

Constructor & Destructor Documentation

SCT_MonitorCondData()

SCT_MonitorCondData::SCT_MonitorCondData

(

)

Constructor.

Definition at line 22 of file SCT_MonitorCondData.cxx.

{
  clear();
}

~SCT_MonitorCondData()

virtual SCT_MonitorCondData::~SCT_MonitorCondData ( )

virtualdefault

Destructor.

Member Function Documentation

badStrips()

const std::array< std::array< std::array< std::bitset< SCT_ConditionsData::STRIPS_PER_CHIP >, SCT_ConditionsData::CHIPS_PER_SIDE >, SCT_ConditionsData::SIDES_PER_MODULE >, SCT_ConditionsData::NUMBER_OF_MODULES > & SCT_MonitorCondData::badStrips ( ) const

inline

Definition at line 67 of file SCT_MonitorCondData.h.

                                                                     {
     return m_badStripArray;
  }

badStripsForModule()

const std::array< std::bitset< SCT_ConditionsData::STRIPS_PER_CHIP >, SCT_ConditionsData::CHIPS_PER_SIDE > & SCT_MonitorCondData::badStripsForModule ( const IdentifierHash & waferHash ) const

inline

Definition at line 58 of file SCT_MonitorCondData.h.

                                                             {
     std::size_t moduleIndex{static_cast<std::size_t>(waferHash/SCT_ConditionsData::SIDES_PER_MODULE)};
     // 0 to 1
     std::size_t waferIndex{static_cast<std::size_t>(waferHash%SCT_ConditionsData::SIDES_PER_MODULE)};
     return m_badStripArray[moduleIndex][waferIndex];
  }

clear()

void SCT_MonitorCondData::clear

(

)

Clear m_defectListArray.

Definition at line 83 of file SCT_MonitorCondData.cxx.

{
  m_defectListArray.fill("");
 
  for (std::size_t moduleIndex{0}; moduleIndex<SCT_ConditionsData::NUMBER_OF_MODULES; moduleIndex++) {
    clearModule(moduleIndex);
  }
}

clearModule()

void SCT_MonitorCondData::clearModule ( const std::size_t moduleIndex )

private

Definition at line 139 of file SCT_MonitorCondData.cxx.

                                                                 {
  // std::array is not automatically initialized.
  for (std::size_t waferIndex{0}; waferIndex<SCT_ConditionsData::SIDES_PER_MODULE; waferIndex++) {
    for (std::size_t chipIndex{0}; chipIndex<SCT_ConditionsData::CHIPS_PER_SIDE; chipIndex++) {
      m_badStripArray[moduleIndex][waferIndex][chipIndex].reset();
      m_badChipArray[moduleIndex][waferIndex][chipIndex] = 0;
    }
    m_badWaferArray[moduleIndex][waferIndex] = 0;
  }
  m_badModuleArray[moduleIndex] = 0;
}

fillBadStrip()

void SCT_MonitorCondData::fillBadStrip ( const std::size_t moduleIndex, const int strip )

private

Definition at line 151 of file SCT_MonitorCondData.cxx.

                                                                                   {
  // 0 <= strip < 1536
  if (strip<0) return;
  if (strip>=SCT_ConditionsData::SIDES_PER_MODULE*SCT_ConditionsData::STRIPS_PER_WAFER) return;
 
  // 0 or 1
  std::size_t waferIndex{static_cast<std::size_t>(strip/SCT_ConditionsData::STRIPS_PER_WAFER)};
  // 0 to 5
  std::size_t chipIndex{static_cast<std::size_t>(strip/SCT_ConditionsData::STRIPS_PER_CHIP)%SCT_ConditionsData::CHIPS_PER_SIDE};
  // 0 to 127
  std::size_t stripIndex{static_cast<std::size_t>(strip%SCT_ConditionsData::STRIPS_PER_CHIP)};
  // Set the strip as bad
  m_badStripArray[moduleIndex][waferIndex][chipIndex].set(stripIndex);
}

find()

bool SCT_MonitorCondData::find	(	const IdentifierHash &	hash,
		std::string &	defectList ) const

Check if a module has a defect (a list of bad strips). If it does not have defect return false.

Definition at line 29 of file SCT_MonitorCondData.cxx.

{
  std::size_t moduleIndex{static_cast<std::size_t>(hash/SCT_ConditionsData::SIDES_PER_MODULE)};
  std::string result{m_defectListArray[moduleIndex]};
  if (result.empty()) return false;
  defectList = std::move(result);
  return true;
}

insert()

void SCT_MonitorCondData::insert	(	const IdentifierHash &	hash,
		const std::string &	defectList )

Insert a new defect (a list of bad strips) for a module.

Definition at line 40 of file SCT_MonitorCondData.cxx.

{
  std::size_t moduleIndex{static_cast<std::size_t>(hash/SCT_ConditionsData::SIDES_PER_MODULE)};
  m_defectListArray[moduleIndex] = defectList;
 
  // Set all strips, chips, wafers and module itself of this module good.
  clearModule(moduleIndex);
 
  if (doesNotHaveNumbers(defectList)) return;
 
  // Fill bad strips
  std::istringstream is{defectList};
  std::istream_iterator<std::string> readString{is};
  std::istream_iterator<std::string> endOfString; //relies on default constructor to produce eof
  for (; readString != endOfString; ++readString) {
    const std::string& stringRange{*readString};
    std::string::size_type p{stringRange.find(s_separator)};
    if (p!=std::string::npos) { //its a range
      std::string::size_type len1{p++};
      std::string::size_type len2{stringRange.size()-p};
      int min{std::stoi(stringRange.substr(0, len1))};
      int max{std::stoi(stringRange.substr(p, len2))};
      for (int strip{min}; strip<=max; strip++) {
        fillBadStrip(moduleIndex, strip);
      }
    } else { //assume its a single number
      int strip{std::stoi(*readString)};
      fillBadStrip(moduleIndex, strip);
    }
  }
 
  // Fill the number of defects in chips, wafers, module
  for (std::size_t waferIndex{0}; waferIndex<SCT_ConditionsData::SIDES_PER_MODULE; waferIndex++) {
    for (std::size_t chipIndex{0}; chipIndex<SCT_ConditionsData::CHIPS_PER_SIDE; chipIndex++) {
      m_badChipArray[moduleIndex][waferIndex][chipIndex] = m_badStripArray[moduleIndex][waferIndex][chipIndex].count();
      m_badWaferArray[moduleIndex][waferIndex] += m_badChipArray[moduleIndex][waferIndex][chipIndex];
    }
    m_badModuleArray[moduleIndex] += m_badWaferArray[moduleIndex][waferIndex];
  }
}

isBadStrip()

bool SCT_MonitorCondData::isBadStrip	(	const IdentifierHash &	waferHash,
		const int	strip ) const

Check if a strip is bad.

Definition at line 121 of file SCT_MonitorCondData.cxx.

{
  // 0 <= strip < 768
  if (strip<0) return false;
  if (strip>=SCT_ConditionsData::STRIPS_PER_WAFER) return false;
  
  // 0 to 4087
  std::size_t moduleIndex{static_cast<std::size_t>(waferHash/SCT_ConditionsData::SIDES_PER_MODULE)};
  // 0 to 1
  std::size_t waferIndex{static_cast<std::size_t>(waferHash%SCT_ConditionsData::SIDES_PER_MODULE)};
  // 0 to 5
  std::size_t chipIndex{static_cast<std::size_t>(strip/SCT_ConditionsData::STRIPS_PER_CHIP)};
  // 0 to 127
  std::size_t stripIndex{static_cast<std::size_t>(strip%SCT_ConditionsData::STRIPS_PER_CHIP)};
 
  return m_badStripArray[moduleIndex][waferIndex][chipIndex].test(stripIndex);
}

nBadStripsForChip()

std::size_t SCT_MonitorCondData::nBadStripsForChip	(	const IdentifierHash &	waferHash,
		const int	strip ) const

Get the number of bad strips for the chip, where a strip locates.

Definition at line 105 of file SCT_MonitorCondData.cxx.

{
  // 0 <= strip < 768
  if (strip<0) return false;
  if (strip>=SCT_ConditionsData::STRIPS_PER_WAFER) return false;
 
  // 0 to 4087
  std::size_t moduleIndex{static_cast<std::size_t>(waferHash/SCT_ConditionsData::SIDES_PER_MODULE)};
  // 0 to 1
  std::size_t waferIndex{static_cast<std::size_t>(waferHash%SCT_ConditionsData::SIDES_PER_MODULE)};
  // 0 to 5
  std::size_t chipIndex{static_cast<std::size_t>(strip/SCT_ConditionsData::STRIPS_PER_CHIP)};
 
  return m_badChipArray[moduleIndex][waferIndex][chipIndex];
}

nBadStripsForModule()

std::size_t SCT_MonitorCondData::nBadStripsForModule

(

const IdentifierHash &

moduleHash

)

const

Get the number of bad strips for a module.

Definition at line 92 of file SCT_MonitorCondData.cxx.

{
  std::size_t moduleIndex{static_cast<std::size_t>(moduleHash/SCT_ConditionsData::SIDES_PER_MODULE)};
  return m_badModuleArray[moduleIndex];
}

nBadStripsForWafer()

std::size_t SCT_MonitorCondData::nBadStripsForWafer

(

const IdentifierHash &

waferHash

)

const

Get the number of bad strips for a wafer.

Definition at line 98 of file SCT_MonitorCondData.cxx.

{
  std::size_t moduleIndex{static_cast<std::size_t>(waferHash/SCT_ConditionsData::SIDES_PER_MODULE)};
  std::size_t waferIndex{static_cast<std::size_t>(waferHash%SCT_ConditionsData::SIDES_PER_MODULE)};
  return m_badWaferArray[moduleIndex][waferIndex];
}

Member Data Documentation

m_badChipArray

std::array<std::array<std::array<std::size_t, SCT_ConditionsData::CHIPS_PER_SIDE>, SCT_ConditionsData::SIDES_PER_MODULE>, SCT_ConditionsData::NUMBER_OF_MODULES> SCT_MonitorCondData::m_badChipArray {}

private

Definition at line 84 of file SCT_MonitorCondData.h.

{};

m_badModuleArray

std::array<std::size_t, SCT_ConditionsData::NUMBER_OF_MODULES> SCT_MonitorCondData::m_badModuleArray {}

private

Definition at line 89 of file SCT_MonitorCondData.h.

{};

m_badStripArray

std::array<std::array<std::array<std::bitset<SCT_ConditionsData::STRIPS_PER_CHIP>, SCT_ConditionsData::CHIPS_PER_SIDE>, SCT_ConditionsData::SIDES_PER_MODULE>, SCT_ConditionsData::NUMBER_OF_MODULES> SCT_MonitorCondData::m_badStripArray

private

Definition at line 80 of file SCT_MonitorCondData.h.

m_badWaferArray

std::array<std::array<std::size_t, SCT_ConditionsData::SIDES_PER_MODULE>, SCT_ConditionsData::NUMBER_OF_MODULES> SCT_MonitorCondData::m_badWaferArray {}

private

Definition at line 87 of file SCT_MonitorCondData.h.

{};

m_defectListArray

std::array<std::string, SCT_ConditionsData::NUMBER_OF_MODULES> SCT_MonitorCondData::m_defectListArray

private

Store the relation between modules and defects (lists of bad strips).

Definition at line 76 of file SCT_MonitorCondData.h.

s_separator

const std::string SCT_MonitorCondData::s_separator {"-"}

staticprivate

Definition at line 166 of file SCT_MonitorCondData.h.

{
public:

  SCT_MonitorCondData();

  virtual ~SCT_MonitorCondData() = default;

  bool find(const IdentifierHash& hash, std::string& defectList) const;

  void insert(const IdentifierHash& hash, const std::string& defectList);

  void clear();

  std::size_t nBadStripsForModule(const IdentifierHash& moduleHash) const;
  std::size_t nBadStripsForWafer(const IdentifierHash& waferHash) const;
  std::size_t nBadStripsForChip(const IdentifierHash& waferHash, const int strip) const;
  bool isBadStrip(const IdentifierHash& waferHash, const int strip) const;
 
  const std::array<std::bitset<SCT_ConditionsData::STRIPS_PER_CHIP>,
                   SCT_ConditionsData::CHIPS_PER_SIDE>
  &badStripsForModule(const IdentifierHash& waferHash) const {
     std::size_t moduleIndex{static_cast<std::size_t>(waferHash/SCT_ConditionsData::SIDES_PER_MODULE)};
     // 0 to 1
     std::size_t waferIndex{static_cast<std::size_t>(waferHash%SCT_ConditionsData::SIDES_PER_MODULE)};
     return m_badStripArray[moduleIndex][waferIndex];
  }
  const std::array<std::array<std::array<std::bitset<SCT_ConditionsData::STRIPS_PER_CHIP>,
    SCT_ConditionsData::CHIPS_PER_SIDE>,
    SCT_ConditionsData::SIDES_PER_MODULE>,
             SCT_ConditionsData::NUMBER_OF_MODULES>& badStrips() const {
     return m_badStripArray;
  }
 
private:
  void clearModule(const std::size_t moduleIndex);
  void fillBadStrip(const std::size_t moduleIndex, const int strip);

  std::array<std::string, SCT_ConditionsData::NUMBER_OF_MODULES> m_defectListArray;
  std::array<std::array<std::array<std::bitset<SCT_ConditionsData::STRIPS_PER_CHIP>,
    SCT_ConditionsData::CHIPS_PER_SIDE>,
    SCT_ConditionsData::SIDES_PER_MODULE>,
    SCT_ConditionsData::NUMBER_OF_MODULES> m_badStripArray;
  std::array<std::array<std::array<std::size_t,
    SCT_ConditionsData::CHIPS_PER_SIDE>,
    SCT_ConditionsData::SIDES_PER_MODULE>,
    SCT_ConditionsData::NUMBER_OF_MODULES> m_badChipArray{};
  std::array<std::array<std::size_t,
    SCT_ConditionsData::SIDES_PER_MODULE>,
    SCT_ConditionsData::NUMBER_OF_MODULES> m_badWaferArray{};
  std::array<std::size_t,
    SCT_ConditionsData::NUMBER_OF_MODULES> m_badModuleArray{};
 
  static const std::string s_separator;
};
 
// Class definition for StoreGate
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( SCT_MonitorCondData , 190515334 , 1 )
 
// Condition container definition for CondInputLoader
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF( SCT_MonitorCondData, 164599336 );
 
#endif // SCT_MONITORCONDDATA_H

---

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

• SCT_MonitorCondData.h
• SCT_MonitorCondData.cxx