SCT_ReadCalibChipDataTool Class Reference

This class contains a Tool that reads SCT calibration data and makes it available to other algorithms. More...

#include <SCT_ReadCalibChipDataTool.h>

Inheritance diagram for SCT_ReadCalibChipDataTool:

Collaboration diagram for SCT_ReadCalibChipDataTool:

Public Member Functions
	SCT_ReadCalibChipDataTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~SCT_ReadCalibChipDataTool ()=default
	Destructor.
virtual StatusCode	initialize () override
	Gaudi initialiser.
virtual StatusCode	finalize () override
	Gaudi finaliser.

Methods to be implemented from virtual baseclass methods, when introduced
Return whether this service can report on the hierarchy level (e.g. module, chip...)
enum	FolderType { NPTGAIN , NOISEOCC , UNKNOWN_FOLDER , N_FOLDERTYPES }
const SCT_ID *	m_id_sct {nullptr}
	Handle to SCT ID helper.
SG::ReadCondHandleKey< SCT_GainCalibData >	m_condKeyGain {this, "CondKeyGain", "SCT_GainCalibData", "SCT calibration data of gains of chips"}
SG::ReadCondHandleKey< SCT_NoiseCalibData >	m_condKeyNoise {this, "CondKeyNoise", "SCT_NoiseCalibData", "SCT calibration data of noises of chips"}
FloatProperty	m_noiseLevel {this, "NoiseLevel", 1800.0, "Noise Level for isGood if ever used"}
virtual bool	canReportAbout (InDetConditions::Hierarchy h) const override
virtual bool	isGood (const Identifier &elementId, const EventContext &ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override
	Summarise the result from the service as good/bad.
virtual bool	isGood (const IdentifierHash &hashId, const EventContext &ctx) const override
	same thing with id hash, introduced by shaun with dummy method for now
virtual void	getDetectorElementStatus (const EventContext &ctx, InDet::SiDetectorElementStatus &element_status, SG::WriteCondHandle< InDet::SiDetectorElementStatus > *whandle) const override
virtual std::vector< float >	getNPtGainData (const Identifier &moduleId, const int side, const std::string &datatype, const EventContext &ctx) const override
	Get NPtGain data per wafer.
virtual std::vector< float >	getNoiseOccupancyData (const Identifier &moduleId, const int side, const std::string &datatype, const EventContext &ctx) const override
	Get NoiseOccupancy data wafer.
static int	nPtGainIndex (const std::string &dataName)
static int	noiseOccIndex (const std::string &dataName)
const SCT_GainCalibData *	getCondDataGain (const EventContext &ctx) const
const SCT_NoiseCalibData *	getCondDataNoise (const EventContext &ctx) const

Detailed Description

This class contains a Tool that reads SCT calibration data and makes it available to other algorithms.

The current implementation reads the data from a COOL database.

Definition at line 34 of file SCT_ReadCalibChipDataTool.h.

Member Enumeration Documentation

FolderType

enum SCT_ReadCalibChipDataTool::FolderType

private

Enumerator
NPTGAIN
NOISEOCC
UNKNOWN_FOLDER
N_FOLDERTYPES

Definition at line 63 of file SCT_ReadCalibChipDataTool.h.

{NPTGAIN, NOISEOCC, UNKNOWN_FOLDER, N_FOLDERTYPES};

Constructor & Destructor Documentation

SCT_ReadCalibChipDataTool()

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

Constructor.

Definition at line 26 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                                            :
  base_class(type, name, parent)
{
}

~SCT_ReadCalibChipDataTool()

virtual SCT_ReadCalibChipDataTool::~SCT_ReadCalibChipDataTool ( )

virtualdefault

Destructor.

Member Function Documentation

canReportAbout()

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

overridevirtual

Definition at line 54 of file SCT_ReadCalibChipDataTool.cxx.

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

finalize()

StatusCode SCT_ReadCalibChipDataTool::finalize ( )

overridevirtual

Gaudi finaliser.

Definition at line 46 of file SCT_ReadCalibChipDataTool.cxx.

                                    {
  // Print where you are
  return StatusCode::SUCCESS;
} // SCT_ReadCalibChipDataTool::finalize()

getCondDataGain()

const SCT_GainCalibData * SCT_ReadCalibChipDataTool::getCondDataGain ( const EventContext & ctx ) const

private

Definition at line 264 of file SCT_ReadCalibChipDataTool.cxx.

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

getCondDataNoise()

const SCT_NoiseCalibData * SCT_ReadCalibChipDataTool::getCondDataNoise ( const EventContext & ctx ) const

private

Definition at line 270 of file SCT_ReadCalibChipDataTool.cxx.

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

getDetectorElementStatus()

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

overridevirtual

Definition at line 105 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                                     {
  SG::ReadCondHandle<SCT_NoiseCalibData> condDataHandle{m_condKeyNoise, ctx};
  if (not condDataHandle.isValid() ) {
    ATH_MSG_ERROR("Invalid cond data handle " << m_condKeyNoise.key() );
    return;
  }
  if (whandle) {
    whandle->addDependency (condDataHandle);
  }
  const SCT_NoiseCalibData* condDataNoise{condDataHandle.cptr() };
  std::vector<bool> &status = element_status.getElementStatus();
  if (status.empty()) {
     status.resize(m_id_sct->wafer_hash_max(),true);
  }
  unsigned int element_i=0;
  const int occ_index{noiseOccIndex("NoiseByChip")};
  for (const SCT_ModuleNoiseCalibData& noiseOccData : *condDataNoise) {
     if (occ_index<0) {
        ATH_MSG_ERROR("This NoiseOccupancy noise data does not exist");
        return;
     }
     const SCT_ModuleCalibParameter& moduleNoiseData{noiseOccData[occ_index]};
 
     for (unsigned int side_i=0; side_i<2; ++side_i) {
        unsigned int chip{side_i*CHIPS_PER_SIDE};
        const unsigned int endChip{CHIPS_PER_SIDE+chip};
        unsigned int nChips{0};
        float sum{0.0};
 
        for (; chip!=endChip; ++chip) {
           float chipNoise{moduleNoiseData[chip]};
           if (chipNoise!=0.0) {
              sum+=chipNoise;
              ++nChips;
           }
        }
        const float meanNoiseValue{ nChips>0 ? sum/nChips : 0.f};
        status.at(element_i) =  status.at(element_i) && (meanNoiseValue < m_noiseLevel);
 
        ++element_i;
     }
  }
}

getNoiseOccupancyData()

std::vector< float > SCT_ReadCalibChipDataTool::getNoiseOccupancyData ( const Identifier & moduleId, const int side, const std::string & datatype, const EventContext & ctx ) const

overridevirtual

Get NoiseOccupancy data wafer.

Definition at line 209 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                                                                     {
  // Print where you are
  ATH_MSG_DEBUG("in getNoiseOccupancyData()");
  std::vector<float> waferData;
 
  // Retrieve SCT_NoiseCalibData pointer
  const SCT_NoiseCalibData* condDataNoise{getCondDataNoise(ctx)};
  if (condDataNoise==nullptr) {
    ATH_MSG_ERROR("In getNPtNoiseData, SCT_NoiseCalibData cannot be retrieved");
    return waferData;
  }
 
  //find hash
  const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
  //make index
  const unsigned int idx{hashId/SIDES_PER_MODULE};
  try {
    //Retrieve defect data from array
    const SCT_ModuleNoiseCalibData& wantedNoiseData{condDataNoise->at(idx)};
 
    //find the correct index for the required data
    const int dataIdx{noiseOccIndex(datatype)};
    if (dataIdx<0) {
      ATH_MSG_ERROR("This Noise Occupancy data: " << datatype << " does not exist");
      return waferData;
    }
    const SCT_ModuleCalibParameter& moduleNoise{wantedNoiseData[dataIdx]};
    const int startOffset{side*CHIPS_PER_SIDE};
    const int endOffset{CHIPS_PER_SIDE+startOffset};
    SCT_ModuleCalibParameter::const_iterator it{moduleNoise.begin() + startOffset};
    SCT_ModuleCalibParameter::const_iterator end{moduleNoise.begin() + endOffset};
    // Returns the data for the wanted wafer
    if (*it != *it) return waferData;
    waferData.assign(it, end);
    return waferData;
  } catch (const std::out_of_range& e) {
    return waferData;
  }
} // SCT_ReadCalibChipDataTool::getNoiseOccupancyData()

getNPtGainData()

std::vector< float > SCT_ReadCalibChipDataTool::getNPtGainData ( const Identifier & moduleId, const int side, const std::string & datatype, const EventContext & ctx ) const

overridevirtual

Get NPtGain data per wafer.

Definition at line 166 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                                                              {
  // Print where you are
  ATH_MSG_DEBUG("in getNPtGainData()");
  std::vector<float> waferData;
 
  // Retrieve SCT_GainCalibData pointer
  const SCT_GainCalibData* condDataGain{getCondDataGain(ctx)};
  if (condDataGain==nullptr) {
    ATH_MSG_ERROR("In getNPtGainData, SCT_GainCalibData cannot be retrieved");
    return waferData;
  }
 
  //find hash
  const IdentifierHash hashId{m_id_sct->wafer_hash(moduleId)};
  //make index
  const unsigned int idx{hashId/SIDES_PER_MODULE};
  //Retrieve defect data from map
  try {
    const SCT_ModuleGainCalibData& wantedNPGData{condDataGain->at(idx)};
    //find the correct index for the required data
    const int dataIdx{nPtGainIndex(datatype)};
    if (dataIdx<0) {
      ATH_MSG_ERROR("This N-point gain data: " << datatype << " does not exist");
      return waferData;
    }
    const SCT_ModuleCalibParameter& moduleGains{wantedNPGData[dataIdx]};
    const int startOffset{side*CHIPS_PER_SIDE};
    const int endOffset{CHIPS_PER_SIDE+startOffset};
    SCT_ModuleCalibParameter::const_iterator it{moduleGains.begin() + startOffset};
    SCT_ModuleCalibParameter::const_iterator end{moduleGains.begin() + endOffset};
    // Returns the data for the wanted wafer
    if (*it != *it) return waferData;
    //could use signaling NaN here and catch the exception instead, would be quicker: NO! 
    //see: http://stackoverflow.com/questions/235386/using-nan-in-c
    waferData.assign(it, end);
    return waferData;
  } catch (const std::out_of_range& e) {
    return waferData;
  }
} //SCT_ReadCalibChipDataTool::getNPtGainData()

initialize()

StatusCode SCT_ReadCalibChipDataTool::initialize ( )

overridevirtual

Gaudi initialiser.

Definition at line 33 of file SCT_ReadCalibChipDataTool.cxx.

                                      {
  // Get SCT helper
  ATH_CHECK(detStore()->retrieve(m_id_sct, "SCT_ID"));
 
  // Read Cond Handle Key
  ATH_CHECK(m_condKeyGain.initialize());
  ATH_CHECK(m_condKeyNoise.initialize());
 
  return StatusCode::SUCCESS;
} // SCT_ReadCalibChipDataTool::initialize()

isGood() [1/2]

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

overridevirtual

Summarise the result from the service as good/bad.

Definition at line 153 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                                        {
  if (h==InDetConditions::SCT_SIDE) { //Could do by chip too
    const IdentifierHash elementIdHash{m_id_sct->wafer_hash(elementId)};
    return isGood(elementIdHash, ctx);
  } else{
    // Not applicable for Calibration data
    ATH_MSG_WARNING("summary(): " << h << "good/bad is not applicable for Calibration data");
    return true;
  }
}

isGood() [2/2]

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

overridevirtual

same thing with id hash, introduced by shaun with dummy method for now

Definition at line 61 of file SCT_ReadCalibChipDataTool.cxx.

                                                                                                    {
  // Retrieve SCT_NoiseCalibData pointer
  const SCT_NoiseCalibData* condDataNoise{getCondDataNoise(ctx)};
  if (condDataNoise==nullptr) {
    ATH_MSG_ERROR("In isGood, SCT_NoiseCalibData cannot be retrieved");
    return true;
  }
 
  const unsigned int moduleIdx{elementHashId/SIDES_PER_MODULE};
  // Retrieve defect data from map
  const SCT_ModuleNoiseCalibData& noiseOccData{(*condDataNoise)[moduleIdx]};
 
  // Retrieve the data
  const int i{noiseOccIndex("NoiseByChip")};
  if (i<0) {
    ATH_MSG_ERROR("This NoiseOccupancy noise data does not exist");
    return true;
  }
  const SCT_ModuleCalibParameter& moduleNoiseData{noiseOccData[i]};
 
  // Calcuate module status
  // For now just simple check NO mean noise level
  // Chip could be 0 if bypassed, need to check
  const int side{static_cast<int>(elementHashId%2)};
  int chip{side*CHIPS_PER_SIDE};
  const int endChip{CHIPS_PER_SIDE+chip};
  int nChips{0};
  float sum{0.0};
  for (; chip!=endChip; ++chip) {
    float chipNoise{moduleNoiseData[chip]};
    if (chipNoise!=0.0) {
      sum+=chipNoise;
      ++nChips;
    }
  }
  if (nChips == 0)[[unlikely]]{
    throw std::runtime_error("SCT_ReadCalibChipDataTool::isGood: nChips is zero.");
  }
  const float meanNoiseValue{sum/nChips};
  ATH_MSG_DEBUG("Module mean noise: " << meanNoiseValue);
  return (meanNoiseValue < m_noiseLevel);
} //SCT_ReadCalibChipDataTool::summary()

noiseOccIndex()

int SCT_ReadCalibChipDataTool::noiseOccIndex ( const std::string & dataName )

staticprivate

Definition at line 257 of file SCT_ReadCalibChipDataTool.cxx.

                                                                  {
  int i{N_NOISEOCC};
  while (i--) if (dataName==noiseOccParameterNames[i]) break;
  return i;
}

nPtGainIndex()

int SCT_ReadCalibChipDataTool::nPtGainIndex ( const std::string & dataName )

staticprivate

Definition at line 250 of file SCT_ReadCalibChipDataTool.cxx.

                                                                 {
  int i{N_NPTGAIN};
  while (i--) if (dataName==nPtGainParameterNames[i]) break;
  return i;
}

Member Data Documentation

m_condKeyGain

SG::ReadCondHandleKey<SCT_GainCalibData> SCT_ReadCalibChipDataTool::m_condKeyGain {this, "CondKeyGain", "SCT_GainCalibData", "SCT calibration data of gains of chips"}

private

Definition at line 76 of file SCT_ReadCalibChipDataTool.h.

{this, "CondKeyGain", "SCT_GainCalibData", "SCT calibration data of gains of chips"};

m_condKeyNoise

SG::ReadCondHandleKey<SCT_NoiseCalibData> SCT_ReadCalibChipDataTool::m_condKeyNoise {this, "CondKeyNoise", "SCT_NoiseCalibData", "SCT calibration data of noises of chips"}

private

Definition at line 77 of file SCT_ReadCalibChipDataTool.h.

{this, "CondKeyNoise", "SCT_NoiseCalibData", "SCT calibration data of noises of chips"};

m_id_sct

const SCT_ID* SCT_ReadCalibChipDataTool::m_id_sct {nullptr}

private

Handle to SCT ID helper.

Definition at line 73 of file SCT_ReadCalibChipDataTool.h.

{nullptr}; 

m_noiseLevel

FloatProperty SCT_ReadCalibChipDataTool::m_noiseLevel {this, "NoiseLevel", 1800.0, "Noise Level for isGood if ever used"}

private

Definition at line 80 of file SCT_ReadCalibChipDataTool.h.

{this, "NoiseLevel", 1800.0, "Noise Level for isGood if ever used"};

---

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

• SCT_ReadCalibChipDataTool.h
• SCT_ReadCalibChipDataTool.cxx