SCT_ReadCalibDataTool Class Reference

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

#include <SCT_ReadCalibDataTool.h>

Inheritance diagram for SCT_ReadCalibDataTool:

Collaboration diagram for SCT_ReadCalibDataTool:

Public Types
enum	{ STRIPS_PER_WAFER =768 }

Public Member Functions
	SCT_ReadCalibDataTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~SCT_ReadCalibDataTool ()=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 tool can report on the hierarchy level (e.g. module, chip...)
SG::ReadCondHandleKey< SCT_CalibDefectData >	m_condKeyGain {this, "CondKeyGain", "SCT_CalibDefectNPtGain", "SCT defects due to NPtGain calibration"}
SG::ReadCondHandleKey< SCT_CalibDefectData >	m_condKeyNoise {this, "CondKeyNoise", "SCT_CalibDefectNPtNoise", "SCT defects due to NPtNoise calibration"}
SG::ReadCondHandleKey< SCT_AllGoodStripInfo >	m_condKeyInfo {this, "CondKeyInfo", "SCT_AllGoodStripInfo", "SCT good strips based on calibration defects"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
ToolHandle< ISCT_CablingTool >	m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}
const SCT_ID *	m_id_sct {nullptr}
	Handle to SCT ID helper.
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 tool as good/bad.
virtual bool	isGood (const IdentifierHash &, const EventContext &) 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 ISCT_ReadCalibDataTool::CalibDefectType	defectType (const Identifier &stripId, const EventContext &ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override
	Return summary of defect type and values for a strip.
virtual SCT_CalibDefectData::CalibModuleDefects	defectsSummary (const Identifier &moduleId, const std::string &scan, const EventContext &ctx) const override
	Returns module summary of defect.
virtual std::list< Identifier >	defectList (const std::string &defect, const EventContext &ctx) const override
	Returns module summary of defect.
const SCT_CalibDefectData *	getCondDataGain (const EventContext &ctx) const
const SCT_CalibDefectData *	getCondDataNoise (const EventContext &ctx) const
const SCT_AllGoodStripInfo *	getCondDataInfo (const EventContext &ctx) const
const InDetDD::SiDetectorElement *	getDetectorElement (const IdentifierHash &waferHash, 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_ReadCalibDataTool.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
STRIPS_PER_WAFER

Definition at line 37 of file SCT_ReadCalibDataTool.h.

{STRIPS_PER_WAFER=768};

Constructor & Destructor Documentation

SCT_ReadCalibDataTool()

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

Constructor.

Definition at line 22 of file SCT_ReadCalibDataTool.cxx.

                                                                                                                   :
  base_class(type, name, parent)
{
}

~SCT_ReadCalibDataTool()

virtual SCT_ReadCalibDataTool::~SCT_ReadCalibDataTool ( )

virtualdefault

Destructor.

Member Function Documentation

canReportAbout()

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

overridevirtual

Definition at line 54 of file SCT_ReadCalibDataTool.cxx.

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

defectList()

std::list< Identifier > SCT_ReadCalibDataTool::defectList ( const std::string & defect, const EventContext & ctx ) const

overridevirtual

Returns module summary of defect.

Definition at line 298 of file SCT_ReadCalibDataTool.cxx.

                                                                                                            {
  std::list<Identifier> defectList;
 
  // Retrieve defect data
  const SCT_CalibDefectData* condDataGain{getCondDataGain(ctx)};
  if (condDataGain==nullptr) {
    ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (gain) cannot be retrieved.");
    return defectList;
  }
  const SCT_CalibDefectData* condDataNoise{getCondDataNoise(ctx)};
  if (condDataNoise==nullptr) {
    ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (noise) cannot be retrieved.");
    return defectList;
  }
 
  // Create pointer to the CalibDataDefect object 
  SCT_CalibDefectData::CalibModuleDefects wantedDefects;
  
  //Check which scan the defect belongs
  bool npDefect{false};
  bool noDefect{false};
  if (defect=="NO_HI" or defect=="BAD_OPE" or defect=="DOUBTR_HI") {
    noDefect = true;
  } else {
    npDefect = true;
  }
  
  //Loop over all wafers using hashIds from the cabling service
  std::vector<std::uint32_t> listOfRODs;
  m_cabling->getAllRods(listOfRODs, ctx);
  std::vector<std::uint32_t>::iterator rodIter{listOfRODs.begin()};
  std::vector<std::uint32_t>::iterator rodEnd{listOfRODs.end()};
  for (; rodIter!=rodEnd; ++rodIter) {
    std::vector<IdentifierHash> listOfHashes;
    m_cabling->getHashesForRod(listOfHashes, *rodIter, ctx);
    std::vector<IdentifierHash>::iterator hashIt{listOfHashes.begin()};
    std::vector<IdentifierHash>::iterator hashEnd{listOfHashes.end()};
    for (; hashIt != hashEnd; ++hashIt) {
      Identifier waferId{m_id_sct->wafer_id(*hashIt)};
      int side{m_id_sct->side(waferId)};
      //Only use the hashid for side 0, since data saved per module basis
      if (side!=0) continue;
      Identifier moduleId{m_id_sct->module_id(waferId)};
      if (npDefect) {
        wantedDefects = condDataGain->findModule(moduleId);
      }  else if (noDefect) {
        wantedDefects = condDataNoise->findModule(moduleId);
      }
      if (not wantedDefects.begDefects.empty()) {
        for (unsigned int i{0}; i < wantedDefects.begDefects.size(); ++i) {
          if (wantedDefects.typeOfDefect[i] == defect) {
            // Create identifier for all strips inside begin to end
            int strip_beg{static_cast<int>(wantedDefects.begDefects[i])};
            int strip_end{static_cast<int>(wantedDefects.endDefects[i])};
            // In DB: strip from 0-1535, need to convert to side and 0-767 and take into account phiSwaps
            for (int strip{strip_beg}; strip<strip_end+1; strip++) {
              int nside{(strip<STRIPS_PER_WAFER) ? 0 : 1};
              int strip_cor;
              const InDetDD::SiDetectorElement* p_element;
              if (nside==1) { // if side 1 need waferId of side 1 to get phiswap and correct stripId
                IdentifierHash hashSide1;
                m_id_sct->get_other_side(*hashIt, hashSide1);
                waferId = m_id_sct->wafer_id(hashSide1);
                p_element = (getDetectorElement(hashSide1, ctx));
              } else {
                p_element = (getDetectorElement(*hashIt, ctx));
              }
              if (p_element->swapPhiReadoutDirection()) {
                if (nside == 0) {
                  strip_cor =   STRIPS_PER_WAFER-1 - strip;
                } else {
                  strip_cor = 2*STRIPS_PER_WAFER-1 - strip;
                }      
              } else {
                strip_cor = strip - nside * STRIPS_PER_WAFER;
              }
              Identifier stripId{m_id_sct->strip_id(waferId,strip_cor)};
              defectList.push_back(stripId);
            }
          }
        }
      }
    }
  }
  return defectList;
} //SCT_ReadCalibDataTool::defects()

defectsSummary()

SCT_CalibDefectData::CalibModuleDefects SCT_ReadCalibDataTool::defectsSummary ( const Identifier & moduleId, const std::string & scan, const EventContext & ctx ) const

overridevirtual

Returns module summary of defect.

Definition at line 269 of file SCT_ReadCalibDataTool.cxx.

                                                                                                                                                            {
  // Create pointer to the CalibDataDefect object 
  SCT_CalibDefectData::CalibModuleDefects wantedDefects;
 
  // Retrieve the correct defect map
  if (scan == "NPtGain") {
    const SCT_CalibDefectData* condDataGain{getCondDataGain(ctx)};
    if (condDataGain==nullptr) {
      ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (gain) cannot be retrieved.");
    } else {
      wantedDefects = condDataGain->findModule(moduleId);
    }
  } else if (scan == "NoiseOccupancy") {
    const SCT_CalibDefectData* condDataNoise{getCondDataNoise(ctx)};
    if (condDataNoise==nullptr) {
      ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (noise) cannot be retrieved.");
    } else {
      wantedDefects = condDataNoise->findModule(moduleId);
    }
  } else {
    ATH_MSG_ERROR("defectsSummary(): Module defects for scan" << scan << " does not exist (only NPtGain or NoiseOccupancy).");
  }
 
  return wantedDefects;
} //SCT_ReadCalibDataTool::defectsSummary()

defectType()

ISCT_ReadCalibDataTool::CalibDefectType SCT_ReadCalibDataTool::defectType ( const Identifier & stripId, const EventContext & ctx, InDetConditions::Hierarchy h = InDetConditions::DEFAULT ) const

overridevirtual

Return summary of defect type and values for a strip.

Definition at line 158 of file SCT_ReadCalibDataTool.cxx.

                                                                                                                                                            {
  // Print where you are
  ATH_MSG_DEBUG("in defectType()");
 
  // Create the calibDefectSummary
  CalibDefectType theseSummaryDefects;
 
  // Retrieve defect data
  const SCT_CalibDefectData* condDataGain{getCondDataGain(ctx)};
  if (condDataGain==nullptr) {
    ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (gain) cannot be retrieved.");
    return theseSummaryDefects;
  }
  const SCT_CalibDefectData* condDataNoise{getCondDataNoise(ctx)};
  if (condDataNoise==nullptr) {
    ATH_MSG_ERROR("In defectType, SCT_CalibDefectData (noise) cannot be retrieved.");
    return theseSummaryDefects;
  }
 
  // Extract the moduleId from the comp identifier
  Identifier moduleId{m_id_sct->module_id(stripId)};
  ATH_MSG_DEBUG("Summary wanted for component: " << stripId << " on module: " << moduleId);
 
  // Create the CalibDataDefect objects
  SCT_CalibDefectData::CalibModuleDefects wantedNPGDefects{condDataGain->findModule(moduleId)};
  SCT_CalibDefectData::CalibModuleDefects wantedNODefects{condDataNoise->findModule(moduleId)};
 
  switch (h) {
  case InDetConditions::SCT_MODULE:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Module defect summary is not applicable for Calibration data");
      break;
    }
 
  case InDetConditions::SCT_SIDE:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Wafer defect summary is not applicable for Calibration data");
      break;
    }
 
  case InDetConditions::SCT_CHIP:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Chip defect summary is not applicable for Calibration data");
      break;
    }
  case InDetConditions::SCT_STRIP:
    {
      // Get the strip/channel number to check
      int side{m_id_sct->side(stripId)};
      int strip{m_id_sct->strip(stripId)};
      const Identifier waferId{m_id_sct->wafer_id(stripId)};
      const IdentifierHash waferHash{m_id_sct->wafer_hash(waferId)};
      unsigned int stripNum;
      const InDetDD::SiDetectorElement* p_element{getDetectorElement(waferHash, ctx)};
      if (p_element->swapPhiReadoutDirection()) {
        if (side == 0) {
          stripNum =   STRIPS_PER_WAFER-1 - strip;
        } else {
          stripNum = 2*STRIPS_PER_WAFER-1 - strip;
        }      
      } else {
        stripNum = side * STRIPS_PER_WAFER + strip;
      }
      
      // Find the bad strip and fill calibDefectSummary
      if (wantedNPGDefects.begDefects.empty()) {
        ATH_MSG_VERBOSE("No NPtGain defects in this module");
      } else {
        for (unsigned int i{0}; i<wantedNPGDefects.begDefects.size(); ++i) {
          if (stripNum>=wantedNPGDefects.begDefects[i] and stripNum<=wantedNPGDefects.endDefects[i]) {
            theseSummaryDefects.scan.emplace_back("NPtGain");
            theseSummaryDefects.defect.push_back(wantedNPGDefects.typeOfDefect[i]);
            theseSummaryDefects.value.push_back(wantedNPGDefects.parValue[i]);
            ATH_MSG_VERBOSE("NPtGain defect summary for strip " << stripNum << " filled");
          }
        }
      }
 
      if (wantedNODefects.begDefects.empty()) {
        ATH_MSG_VERBOSE("No NoiseOccupancy defects in this module");
      } else {
        for (unsigned int i{0}; i != wantedNODefects.begDefects.size(); ++i) {
          if (stripNum>=wantedNODefects.begDefects[i] and stripNum <= wantedNODefects.endDefects[i]) {
            theseSummaryDefects.scan.emplace_back("NoiseOccupancy");
            theseSummaryDefects.defect.push_back(wantedNODefects.typeOfDefect[i]);
            theseSummaryDefects.value.push_back(wantedNODefects.parValue[i]);
            ATH_MSG_VERBOSE("NoiseOccupancy defect summary for strip " << stripNum << "  filled");
          }
        }
      } 
      if (theseSummaryDefects.scan.empty()) {
        ATH_MSG_VERBOSE("defectSummary(): can't retrieve the defects for this strip: " <<  stripNum << " since strip good");
      }     
      break;
    }
  default:
    {
      ATH_MSG_INFO("Unknown component requested, should be one of Module/Side/Chip or Strip");
      return theseSummaryDefects;
    }
 
  }//end of switch structure
 
  return theseSummaryDefects;
} //SCT_ReadCalibDataTool::defectType()

finalize()

StatusCode SCT_ReadCalibDataTool::finalize ( )

overridevirtual

Gaudi finaliser.

Definition at line 48 of file SCT_ReadCalibDataTool.cxx.

                                           {
  return StatusCode::SUCCESS;
} // SCT_ReadCalibDataTool::finalize()

getCondDataGain()

const SCT_CalibDefectData * SCT_ReadCalibDataTool::getCondDataGain ( const EventContext & ctx ) const

private

Definition at line 388 of file SCT_ReadCalibDataTool.cxx.

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

getCondDataInfo()

const SCT_AllGoodStripInfo * SCT_ReadCalibDataTool::getCondDataInfo ( const EventContext & ctx ) const

private

Definition at line 404 of file SCT_ReadCalibDataTool.cxx.

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

getCondDataNoise()

const SCT_CalibDefectData * SCT_ReadCalibDataTool::getCondDataNoise ( const EventContext & ctx ) const

private

Definition at line 396 of file SCT_ReadCalibDataTool.cxx.

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

getDetectorElement()

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

private

Definition at line 412 of file SCT_ReadCalibDataTool.cxx.

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

getDetectorElementStatus()

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

overridevirtual

Definition at line 110 of file SCT_ReadCalibDataTool.cxx.

                                                                                                                     {
   SG::ReadCondHandle<SCT_AllGoodStripInfo> condDataHandle{m_condKeyInfo, ctx};
   if (not condDataHandle.isValid()) {
      ATH_MSG_ERROR("Invalid cond data handle " << m_condKeyInfo.key() );
      return;
   }
   if (whandle) {
     whandle->addDependency (condDataHandle);
   }
   const SCT_AllGoodStripInfo* condDataInfo{condDataHandle.cptr()};
 
   const std::vector<bool> &status = element_status.getElementStatus();
   const std::vector<InDet::ChipFlags_t> &chip_status = element_status.getElementChipStatus();
 
   std::vector<std::vector<unsigned short> >  &bad_strips = element_status.getBadCells();
   if (bad_strips.empty()) {
      bad_strips.resize(condDataInfo->size());
   }
   unsigned int element_i=0;
   for( const std::array<bool, SCT_ConditionsData::STRIPS_PER_WAFER> &good_strips : *condDataInfo) {
      IdentifierHash moduleHash(element_i);
      if (status.empty() || status.at(element_i)) {
         std::vector<unsigned short>  &bad_module_strips = bad_strips[element_i];
         unsigned int last_geoemtrical_chip_id=SCT::N_CHIPS_PER_SIDE;
         for (unsigned int strip_i=0; strip_i<good_strips.size(); ++strip_i) {
            unsigned int geoemtrical_chip_id = SCT::getGeometricalChipID(strip_i);
            if (geoemtrical_chip_id != last_geoemtrical_chip_id) {
               last_geoemtrical_chip_id=geoemtrical_chip_id;
               if (!chip_status.empty() && !(chip_status.at(element_i) & static_cast<InDet::ChipFlags_t>(1ul<<geoemtrical_chip_id))) {
                  strip_i += (SCT::N_STRIPS_PER_CHIP-1);
                  continue;
               }
            }
            if (!good_strips[strip_i]) {
               std::vector<unsigned short>::const_iterator iter = std::lower_bound(bad_module_strips.begin(),bad_module_strips.end(),strip_i);
               if (iter == bad_module_strips.end() || *iter != strip_i) {
                  bad_module_strips.insert( iter, strip_i);
               }
            }
         }
      }
      ++element_i;
   }
}

initialize()

StatusCode SCT_ReadCalibDataTool::initialize ( )

overridevirtual

Gaudi initialiser.

Definition at line 28 of file SCT_ReadCalibDataTool.cxx.

                                             {
  // Print where you are
  ATH_MSG_DEBUG("in initialize()");
 
  // Get SCT helper
  ATH_CHECK(detStore()->retrieve(m_id_sct, "SCT_ID"));
 
  // Retrieve SCT Cabling tool
  ATH_CHECK(m_cabling.retrieve());
 
  // Read Cond Handle Key
  ATH_CHECK(m_condKeyGain.initialize());
  ATH_CHECK(m_condKeyNoise.initialize());
  ATH_CHECK(m_condKeyInfo.initialize());
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  return StatusCode::SUCCESS;
} // SCT_ReadCalibDataTool::initialize()

isGood() [1/2]

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

overridevirtual

Summarise the result from the tool as good/bad.

Definition at line 60 of file SCT_ReadCalibDataTool.cxx.

                                                                                                                         {
  // Status of the compId
  bool status{true};
  switch (h) {
  case InDetConditions::SCT_STRIP:
    {
      // Retrieve isGood Wafer data
      const SCT_AllGoodStripInfo* condDataInfo{getCondDataInfo(ctx)};
      if (condDataInfo==nullptr) {
        ATH_MSG_ERROR("In isGood, SCT_AllGoodStripInfo cannot be retrieved");
        return false;
      }
      // Extract the wafer identifier from the strip identifier
      Identifier waferId{m_id_sct->wafer_id(elementId)};
      // Get hashId
      IdentifierHash waferHash{m_id_sct->wafer_hash(waferId)};
      // Get strip on wafer to check
      int strip{m_id_sct->strip(elementId)};
      // Set value
      status = (*condDataInfo)[waferHash][strip];
      break;
    }
  case InDetConditions::SCT_MODULE:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Module good/bad is not applicable for Calibration data");
      break;
    }
  case InDetConditions::SCT_SIDE:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Wafer good/bad is not applicable for Calibration data");
      break;
    }
  case InDetConditions::SCT_CHIP:
    {
      // Not applicable for Calibration data
      ATH_MSG_WARNING("summary(): Chip good/bad is not applicable for Calibration data");
      break;
    }
  default:
    {
      ATH_MSG_INFO("Unknown component has been asked for, should be Module/Wafer/Chip or Strip; returning 'good' and continuing");
    }    
  } //end of switch structure
  
  // Print status  
  return status;
} //SCT_ReadCalibDataTool::summary()

isGood() [2/2]

virtual bool SCT_ReadCalibDataTool::isGood ( const IdentifierHash & , const EventContext &  ) const

inlineoverridevirtual

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

Definition at line 53 of file SCT_ReadCalibDataTool.h.

{ return true; }

Member Data Documentation

m_cabling

ToolHandle<ISCT_CablingTool> SCT_ReadCalibDataTool::m_cabling {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}

private

Definition at line 76 of file SCT_ReadCalibDataTool.h.

{this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"};

m_condKeyGain

SG::ReadCondHandleKey<SCT_CalibDefectData> SCT_ReadCalibDataTool::m_condKeyGain {this, "CondKeyGain", "SCT_CalibDefectNPtGain", "SCT defects due to NPtGain calibration"}

private

Definition at line 65 of file SCT_ReadCalibDataTool.h.

{this, "CondKeyGain", "SCT_CalibDefectNPtGain", "SCT defects due to NPtGain calibration"};

m_condKeyInfo

SG::ReadCondHandleKey<SCT_AllGoodStripInfo> SCT_ReadCalibDataTool::m_condKeyInfo {this, "CondKeyInfo", "SCT_AllGoodStripInfo", "SCT good strips based on calibration defects"}

private

Definition at line 67 of file SCT_ReadCalibDataTool.h.

{this, "CondKeyInfo", "SCT_AllGoodStripInfo", "SCT good strips based on calibration defects"};

m_condKeyNoise

SG::ReadCondHandleKey<SCT_CalibDefectData> SCT_ReadCalibDataTool::m_condKeyNoise {this, "CondKeyNoise", "SCT_CalibDefectNPtNoise", "SCT defects due to NPtNoise calibration"}

private

Definition at line 66 of file SCT_ReadCalibDataTool.h.

{this, "CondKeyNoise", "SCT_CalibDefectNPtNoise", "SCT defects due to NPtNoise calibration"};

m_id_sct

const SCT_ID* SCT_ReadCalibDataTool::m_id_sct {nullptr}

private

Handle to SCT ID helper.

Definition at line 77 of file SCT_ReadCalibDataTool.h.

{nullptr}; 

m_SCTDetEleCollKey

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

private

Definition at line 68 of file SCT_ReadCalibDataTool.h.

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

---

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

• SCT_ReadCalibDataTool.h
• SCT_ReadCalibDataTool.cxx