SCT_ConfigurationCondAlg Class Reference

#include <SCT_ConfigurationCondAlg.h>

Inheritance diagram for SCT_ConfigurationCondAlg:

Collaboration diagram for SCT_ConfigurationCondAlg:

Public Member Functions
	SCT_ConfigurationCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~SCT_ConfigurationCondAlg ()=default
virtual StatusCode	initialize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
virtual StatusCode	finalize () override final
virtual bool	isReEntrant () const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum	{ badLink =255 , stripsPerChip =128 , lastStrip =767 }
	enum for constants More...
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	fillChannelData (SCT_ConfigurationCondData *writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > &writeHandle, const EventContext &ctx) const
StatusCode	fillModuleData (SCT_ConfigurationCondData *writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > &writeHandle, const EventContext &ctx) const
StatusCode	fillLinkStatus (SCT_ConfigurationCondData *writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > &writeHandle, const EventContext &ctx) const
Identifier	getStripId (const unsigned int truncatedSerialNumber, const unsigned int chipNumber, const unsigned int stripNumber, const InDetDD::SiDetectorElementCollection *elements, const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< CondAttrListVec >	m_readKeyChannel {this, "ReadKeyChannel", "/SCT/DAQ/Config/Chip", "Key of input (raw) conditions folder of chips"}
SG::ReadCondHandleKey< CondAttrListVec >	m_readKeyModule {this, "ReadKeyModule", "/SCT/DAQ/Config/Module", "Key of input (raw) conditions folder of modules"}
SG::ReadCondHandleKey< CondAttrListVec >	m_readKeyMur {this, "ReadKeyMur", "/SCT/DAQ/Config/MUR", "Key of input (raw) conditions folder of Murs"}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
SG::WriteCondHandleKey< SCT_ConfigurationCondData >	m_writeKey {this, "WriteKey", "SCT_ConfigurationCondData", "Key of output (derived) conditions data"}
ServiceHandle< ICondSvc >	m_condSvc {this, "CondSvc", "CondSvc"}
ToolHandle< ISCT_CablingTool >	m_cablingTool {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}
	Handle on SCT cabling service.
ToolHandle< ISCT_ReadoutTool >	m_readoutTool {this, "SCT_ReadoutTool", "SCT_ReadoutTool", "Handle on readout tool"}
	Handle on readout tool.
const SCT_ID *	m_pHelper {nullptr}
	ID helper for SCT.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const std::string	s_coolChannelFolderName {"/SCT/DAQ/Configuration/Chip"}
static const std::string	s_coolChannelFolderName2 {"/SCT/DAQ/Config/Chip"}
static const std::string	s_coolChannelFolderName2Slim {"/SCT/DAQ/Config/ChipSlim"}
static const std::string	s_coolModuleFolderName {"/SCT/DAQ/Configuration/Module"}
static const std::string	s_coolModuleFolderName2 {"/SCT/DAQ/Config/Module"}
static const std::string	s_coolMurFolderName {"/SCT/DAQ/Configuration/MUR"}
static const std::string	s_coolMurFolderName2 {"/SCT/DAQ/Config/MUR"}

Detailed Description

Definition at line 30 of file SCT_ConfigurationCondAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

enum for constants

Enumerator
badLink
stripsPerChip
lastStrip

Definition at line 42 of file SCT_ConfigurationCondAlg.h.

{badLink=255, stripsPerChip=128, lastStrip=767};

Constructor & Destructor Documentation

SCT_ConfigurationCondAlg()

SCT_ConfigurationCondAlg::SCT_ConfigurationCondAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 30 of file SCT_ConfigurationCondAlg.cxx.

  : ::AthReentrantAlgorithm(name, pSvcLocator)
{
}

~SCT_ConfigurationCondAlg()

virtual SCT_ConfigurationCondAlg::~SCT_ConfigurationCondAlg ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode SCT_ConfigurationCondAlg::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 73 of file SCT_ConfigurationCondAlg.cxx.

                                                                          {
  ATH_MSG_DEBUG("execute " << name());
 
  // Write Cond Handle
  SG::WriteCondHandle<SCT_ConfigurationCondData> writeHandle{m_writeKey, ctx};
  // Do we have a valid Write Cond Handle for current time?
  if (writeHandle.isValid()) {
    ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
                  << ". In theory this should not be called, but may happen"
                  << " if multiple concurrent events are being processed out of order.");
    return StatusCode::SUCCESS;
  }
 
  // Construct the output Cond Object and fill it in
  std::unique_ptr<SCT_ConfigurationCondData> writeCdo{std::make_unique<SCT_ConfigurationCondData>()};
  // clear structures before filling
  writeCdo->clear();
 
  // Fill module data
  if (fillModuleData(writeCdo.get(), writeHandle, ctx).isFailure()) {
    return StatusCode::FAILURE;
  }
 
  // Fill strip, chip and link info if Chip or MUR folders change
  if (fillChannelData(writeCdo.get(), writeHandle, ctx).isFailure()) {
    return StatusCode::FAILURE;
  }
 
  if (writeHandle.record(std::move(writeCdo)).isFailure()) {
    ATH_MSG_FATAL("Could not record SCT_ConfigurationCondData " << writeHandle.key() 
                  << " with EventRange " << writeHandle.getRange()
                  << " into Conditions Store");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << writeHandle.getRange() << " into Conditions Store");
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

fillChannelData()

StatusCode SCT_ConfigurationCondAlg::fillChannelData ( SCT_ConfigurationCondData * writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > & writeHandle, const EventContext & ctx ) const

private

Definition at line 113 of file SCT_ConfigurationCondAlg.cxx.

                                                                                                                                                                                  {
  // Check if the pointer of derived conditions object is valid.
  if (writeCdo==nullptr) {
    ATH_MSG_FATAL("Pointer of derived conditions object is null");
    return StatusCode::FAILURE;
  }
 
  unsigned int nDisabledChips{0};
  unsigned int nDisabledChipsExclusive{0};
  unsigned int nDisabledStripsExclusive{0};
  const std::string channelFolderName{m_readKeyChannel.key()};
  const bool run1{channelFolderName==s_coolChannelFolderName};
  const bool slim{channelFolderName==s_coolChannelFolderName2Slim};
 
  // indices change according to whether CoraCool or CoolVectorPayload
  enum RUN1_MODULE_INDICES{PK, FOREIGN_KEY, CRATE_1, ROD_1, CHANNEL_1,OUTPUTCURRENT_1,
                           OUTPUTDELAY_1, OUTPUT_TOF_DELTA_1, OUTPUTMARKSPACE_1, STREAM0THRESHOLD_1,
                           STREAM0DELAY_1, STREAM0ERRMASK_1, STREAM1THRESHOLD_1, STREAM1DELAY_1, STREAM1ERRMASK_1};
  enum RUN2_MODULE_INDICES{CRATE_2, ROD_2, CHANNEL_2,OUTPUTCURRENT_2,
                           OUTPUTDELAY_2, OUTPUTMARKSPACE_2, STREAM0THRESHOLD_2,
                           STREAM0DELAY_2, STREAM0ERRMASK_2, STREAM1THRESHOLD_2, STREAM1DELAY_2, STREAM1ERRMASK_2};
  enum RUN1_CHIP_INDICES{CHIP_PK, CHIP_FOREIGN_KEY,CHIP_1, ACTIVE_1,ADDRESS_1, CONFIG_1,
                         MASK0_1,MASK1_1,MASK2_1,MASK3_1, VTHR_1, VCAL_1, DELAY_1, PREAMP_1, SHAPER_1,
                         RC_FUNCTION_1, RC_ARGS_1, C_FACTOR_1, TARGET_1, TRIM_1};
  enum RUN2_CHIP_INDICES{CHIP_2, ACTIVE_2, ADDRESS_2, CONFIG_2, MASK0_2,MASK1_2,MASK2_2,
                         MASK3_2, VTHR_2, VCAL_2, DELAY_2, PREAMP_2, SHAPER_2, RC_FUNCTION_2, RC_ARGS_2,
                         C_FACTOR_2, TARGET_2, TRIM_2};
  enum RUN2_CHIPSLIM_INDICES{CHIP_2_SLIM, CONFIG_2_SLIM, MASK0_2_SLIM, MASK1_2_SLIM, MASK2_2_SLIM,
                             MASK3_2_SLIM};
  const unsigned int chipIndex{  run1 ? static_cast<unsigned int>(CHIP_1)   : slim ? static_cast<unsigned int>(CHIP_2_SLIM)   : static_cast<unsigned int>(CHIP_2)};
  const unsigned int configIndex{run1 ? static_cast<unsigned int>(CONFIG_1) : slim ? static_cast<unsigned int>(CONFIG_2_SLIM) : static_cast<unsigned int>(CONFIG_2)};
  const unsigned int mask0Index{ run1 ? static_cast<unsigned int>(MASK0_1)  : slim ? static_cast<unsigned int>(MASK0_2_SLIM)  : static_cast<unsigned int>(MASK0_2)};
  const unsigned int mask1Index{ run1 ? static_cast<unsigned int>(MASK1_1)  : slim ? static_cast<unsigned int>(MASK1_2_SLIM)  : static_cast<unsigned int>(MASK1_2)};
  const unsigned int mask2Index{ run1 ? static_cast<unsigned int>(MASK2_1)  : slim ? static_cast<unsigned int>(MASK2_2_SLIM)  : static_cast<unsigned int>(MASK2_2)};
  const unsigned int mask3Index{ run1 ? static_cast<unsigned int>(MASK3_1)  : slim ? static_cast<unsigned int>(MASK3_2_SLIM)  : static_cast<unsigned int>(MASK3_2)};
 
  // Clear previous information at callback
  writeCdo->clearBadStripIds();
  writeCdo->clearBadChips();
  // Fill link status
  if (fillLinkStatus(writeCdo, writeHandle, ctx).isFailure()) return StatusCode::FAILURE;
 
  // Get channel folder for link info 
  SG::ReadCondHandle<CondAttrListVec> readHandle{m_readKeyChannel, ctx};
  const CondAttrListVec* readCdo{*readHandle};
  if (readCdo==nullptr) {
    ATH_MSG_FATAL("Could not find MUR configuration data: " << m_readKeyChannel.key());
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Size of " << m_readKeyChannel.key() << " folder is " << readCdo->size());
  // Add dependency
  writeHandle.addDependency(readHandle);
 
  // Get SCT_DetectorElementCollection
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle{m_SCTDetEleCollKey, ctx};
  const InDetDD::SiDetectorElementCollection* elements(sctDetEle.retrieve());
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
    return StatusCode::FAILURE;
  }
  // Add dependency
  writeHandle.addDependency(sctDetEle);
 
  // Loop over modules (i.e groups of 12 chips) in DB folder 
  CondAttrListVec::const_iterator itr{readCdo->begin()};
  CondAttrListVec::const_iterator end{readCdo->end()};
  constexpr unsigned int nChips{12};
  for (; itr!=end; itr+=nChips) {
    // Get SN and identifiers (the channel number is serial number+1 for the CoraCool folders but =serial number 
    // for Cool Vector Payload ; i.e. Run 1 and Run 2 resp.)
    const unsigned int truncatedSerialNumber{run1 ? (itr->first-1) : (itr->first)};
    const IdentifierHash& hash{m_cablingTool->getHashFromSerialNumber(truncatedSerialNumber, ctx)};
    if (not hash.is_valid()) continue;
    const Identifier waferId{m_pHelper->wafer_id(hash)};
    const Identifier moduleId{m_pHelper->module_id(waferId)};
 
    IdentifierHash oppWaferHash;
    m_pHelper->get_other_side(hash, oppWaferHash);
    const Identifier oppWaferId{m_pHelper->wafer_id(oppWaferHash)};
    bool isBadModule{writeCdo->isBadModuleId(moduleId)};
 
    // Get link status 
    // Can maybe be smarter if both links are bad (but the module will probably be bad then)
    std::pair<bool, bool> linkResults{writeCdo->areBadLinks(hash)};
    bool link0ok{linkResults.first};
    bool link1ok{linkResults.second};
    // Loop over chips within module
    std::vector<SCT_Chip> chipsInMod;
    chipsInMod.reserve(nChips);
    bool isBadSide0{true};
    bool isBadSide1{true};
    CondAttrListVec::const_iterator channelItr{itr};
    CondAttrListVec::const_iterator channelEnd{itr+nChips};
    for (; channelItr!=channelEnd; ++channelItr) {
      // Get chip id, config and masks and store as SCT_Chip object
      // Can get AttributeList from second (see https://svnweb.cern.ch/trac/lcgcoral/browser/coral/trunk/src/CoralBase/CoralBase/AttributeList.h )
      const short id{    run1 ? (channelItr->second[chipIndex].data<short>())   : static_cast<short>(channelItr->second[chipIndex].data<unsigned char>())};
      const short config{run1 ? (channelItr->second[configIndex].data<short>()) : static_cast<short>(channelItr->second[configIndex].data<unsigned short>())};
      const int mask0{   run1 ? (channelItr->second[mask0Index].data<int>())    : static_cast<int>(channelItr->second[mask0Index].data<unsigned int>())};
      const int mask1{   run1 ? (channelItr->second[mask1Index].data<int>())    : static_cast<int>(channelItr->second[mask1Index].data<unsigned int>())};
      const int mask2{   run1 ? (channelItr->second[mask2Index].data<int>())    : static_cast<int>(channelItr->second[mask2Index].data<unsigned int>())};
      const int mask3{   run1 ? (channelItr->second[mask3Index].data<int>())    : static_cast<int>(channelItr->second[mask3Index].data<unsigned int>())};
      chipsInMod.emplace_back(id, config, mask0, mask1, mask2, mask3);
      if (id>=0 and id< 6 and (mask0!=0 or mask1!=0 or mask2!=0 or mask3!=0)) isBadSide0 = false;
      if (id>=6 and id<12 and (mask0!=0 or mask1!=0 or mask2!=0 or mask3!=0)) isBadSide1 = false;
    }
    if (isBadSide0) writeCdo->setBadWaferId(waferId);
    if (isBadSide1) writeCdo->setBadWaferId(oppWaferId);
    
    // Check the module readout to look for bypassed chips, disabled links etc
    if (m_readoutTool->determineReadout(moduleId, chipsInMod, link0ok, link1ok).isFailure()) return StatusCode::FAILURE;
 
    // Loop over chips again now know whether they're in the readout
    std::vector<int> badStripsVec;
    unsigned int chipStatusWord{0};
    for (const auto& thisChip:chipsInMod) {
      // Bad strips (only need to do this if at least one bad channel)
      if (thisChip.numberOfMaskedChannels()!=0) {
        // Add bad stips to vector
        badStripsVec.clear();
        thisChip.appendBadStripsToVector(badStripsVec);
        // Loop over bad strips and insert strip ID into set
        for (const auto& thisBadStrip:badStripsVec) {
          const Identifier stripId{getStripId(truncatedSerialNumber, thisChip.id(), thisBadStrip, elements, ctx)};
          // If in rough order, may be better to call with itr of previous insertion as a suggestion    
          if (stripId.is_valid()) writeCdo->setBadStripId(stripId, // strip Identifier
                                                          thisChip.id()<6 ? hash : oppWaferHash, // wafer IdentifierHash
                                                          m_pHelper->strip(stripId)); // strip number from 0 to 768
        }
      }
      // Bad chips (= all strips bad) bitpacked
      // Should only do this for modules with at least one chip bad?
      if (thisChip.numberOfMaskedChannels()==stripsPerChip) {
        chipStatusWord |= (1<<thisChip.id());
        nDisabledChips++; // A bad chip
        if (not isBadModule) nDisabledChipsExclusive++; // A bad chip in a good module
      } else { // Good chip
        if (not isBadModule) nDisabledStripsExclusive += thisChip.numberOfMaskedChannels(); // Bad strips in a good chip of a good module
      }
    }
 
    // Store chip status if not all good (==0)
    if (chipStatusWord!=0) {
      writeCdo->setBadChips(moduleId, chipStatusWord);
    }
  }
 
  const long unsigned int totalBad{writeCdo->getBadStripIds()->size()};
  ATH_MSG_INFO("Total number of bad chips is " << nDisabledChips);
  ATH_MSG_INFO("Total number of bad chips not in bad modules is " << nDisabledChipsExclusive);
  ATH_MSG_INFO("Total number of bad strip identifiers is " << totalBad);
  ATH_MSG_INFO("Total number of bad strip identifiers not in bad modules nor bad chips is " << nDisabledStripsExclusive);
  
  return StatusCode::SUCCESS;
}

fillLinkStatus()

StatusCode SCT_ConfigurationCondAlg::fillLinkStatus ( SCT_ConfigurationCondData * writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > & writeHandle, const EventContext & ctx ) const

private

Definition at line 340 of file SCT_ConfigurationCondAlg.cxx.

                                                                                                                                                                                 {
  // Check if the pointer of derived conditions object is valid.
  if (writeCdo==nullptr) {
    ATH_MSG_FATAL("Pointer of derived conditions object is null");
    return StatusCode::FAILURE;
  }
 
  const std::string murFolderName{m_readKeyMur.key()};
  const bool run1{murFolderName==s_coolMurFolderName};
 
  // Clear previous information at call back
  writeCdo->clearBadLinks();
 
  // Get MUR folder for link info 
  SG::ReadCondHandle<CondAttrListVec> readHandle{m_readKeyMur, ctx};
  const CondAttrListVec* readCdo{*readHandle};
  if (readCdo==nullptr) {
    ATH_MSG_FATAL("Could not find MUR configuration data: " << m_readKeyMur.key());
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Size of " << m_readKeyMur.key() << " is " << readCdo->size());
 
  // Add dependency
  writeHandle.addDependency(readHandle);
 
  // Set indices
  enum RUN1_INDICES{PK, FOREIGN_KEY, MUR_1, MODULE_1, MODULEID_1, RMODULEID_1, RX0FIBRE_1, RX1FIBRE_1, TXFIBRE_1};
  enum RUN2_INDICES{MUR_2, MODULE_2, MODULEID_2, RMODULEID_2, RX0FIBRE_2, RX1FIBRE_2, TXFIBRE_2};
  const unsigned int snIndex{   run1 ? static_cast<unsigned int>(MODULEID_1) : static_cast<unsigned int>(MODULEID_2)};
  const unsigned int link0Index{run1 ? static_cast<unsigned int>(RX0FIBRE_1) : static_cast<unsigned int>(RX0FIBRE_2)};
  const unsigned int link1Index{run1 ? static_cast<unsigned int>(RX1FIBRE_1) : static_cast<unsigned int>(RX1FIBRE_2)};
 
  // loop over MUR folder
  CondAttrListVec::const_iterator itr{readCdo->begin()};
  CondAttrListVec::const_iterator end{readCdo->end()};
  for (; itr!=end; ++itr) {
    // Check for null values
    if (itr->second[snIndex].isNull()) continue;
    // Check serial number
    const long long ullSerialNumber{itr->second[snIndex].data<long long>()};
    const SCT_SerialNumber serialNumber{ullSerialNumber};
    if (not serialNumber.is_valid()) continue;
    // Check module hash
    const IdentifierHash& hash{m_cablingTool->getHashFromSerialNumber(serialNumber.to_uint(), ctx)};
    if (not hash.is_valid()) continue;
 
    int link0{run1 ? (itr->second[link0Index].data<int>()) : static_cast<int>(itr->second[link0Index].data<unsigned char>())};
    int link1{run1 ? (itr->second[link1Index].data<int>()) : static_cast<int>(itr->second[link1Index].data<unsigned char>())};
 
    // Store the modules with bad links, represented by badLink (enum in header) = 255 = 0xFF 
    if (link0==badLink or link1==badLink) {
      writeCdo->setBadLinks(hash, (link0!=badLink), (link1!=badLink));
    }
  }
 
  return StatusCode::SUCCESS;
}

fillModuleData()

StatusCode SCT_ConfigurationCondAlg::fillModuleData ( SCT_ConfigurationCondData * writeCdo, SG::WriteCondHandle< SCT_ConfigurationCondData > & writeHandle, const EventContext & ctx ) const

private

Definition at line 270 of file SCT_ConfigurationCondAlg.cxx.

                                                                                                                                                                                 {
  // Check if the pointer of derived conditions object is valid.
  if (writeCdo==nullptr) {
    ATH_MSG_FATAL("Pointer of derived conditions object is null");
    return StatusCode::FAILURE;
  }
 
  const std::string moduleFolderName{m_readKeyModule.key()};
  const bool run1{moduleFolderName==s_coolModuleFolderName};
  unsigned int totalNumberOfModules{0};
  unsigned int totalNumberOfValidModules{0};
 
  // Clear previous information at callback
  writeCdo->clearBadModuleIds();
  writeCdo->clearBadWaferIds();
 
  // Get Module folder
  SG::ReadCondHandle<CondAttrListVec> readHandle{m_readKeyModule, ctx};
  const CondAttrListVec* readCdo{*readHandle};
  if (readCdo==nullptr) {
    ATH_MSG_FATAL("Could not find MUR configuration data: " << m_readKeyModule.key());
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Size of " << m_readKeyModule.key() << " is " << readCdo->size());
 
  // Add dependency
  writeHandle.addDependency(readHandle);
 
  // Set index
  enum RUN1_INDICES{PK, FOREIGN_KEY, ID_1, GROUP_1, ACTIVE_1, SELECT_1};
  enum RUN2_INDICES{ID_2, SLAVEGROUP_2, ACTIVE_2, CLOCKSELECT_2, CHIPSTATUS_2};
  const unsigned int groupIndex{run1 ? static_cast<unsigned int>(GROUP_1) : static_cast<unsigned int>(SLAVEGROUP_2)};
 
  // Loop over modules in DB folder
  CondAttrListVec::const_iterator itr{readCdo->begin()};
  CondAttrListVec::const_iterator end{readCdo->end()};
  for (; itr!=end; ++itr) {
    // Get SN and identifiers (the channel number is serial number+1 for the CoraCool folders but =serial number 
    //  for Cool Vector Payload ; i.e. Run 1 and Run 2 resp.)
    const unsigned int truncatedSerialNumber{run1 ? (itr->first-1) : (itr->first)};
    const IdentifierHash& hash{m_cablingTool->getHashFromSerialNumber(truncatedSerialNumber, ctx)};
    ++totalNumberOfModules;
    if (not hash.is_valid()) continue;
 
    Identifier waferId{m_pHelper->wafer_id(hash)};
    ++totalNumberOfValidModules;
    IdentifierHash oppWaferHash;
    m_pHelper->get_other_side(m_cablingTool->getHashFromSerialNumber(truncatedSerialNumber, ctx), oppWaferHash);
    const Identifier oppWaferId{m_pHelper->wafer_id(oppWaferHash)};
    const Identifier moduleId{m_pHelper->module_id(waferId)};
    // Get AttributeList from second (see https://svnweb.cern.ch/trac/lcgcoral/browser/coral/trunk/src/CoralBase/CoralBase/AttributeList.h )
    // and get module info from this.  Bad module has a -ve group.
    const short group{itr->second[groupIndex].data<short>()};
    if (group<0) { 
      // Insert module/wafer ID into set of bad modules/wafers IDs
      writeCdo->setBadModuleId(moduleId);
      writeCdo->setBadWaferId(waferId);
      writeCdo->setBadWaferId(oppWaferId);
    }
  }  
 
  const long unsigned int totalBad{writeCdo->getBadModuleIds()->size()};
  ATH_MSG_INFO("Total number of module identifiers is " << totalNumberOfModules);
  ATH_MSG_INFO("Total number of modules also found in the cabling is " << totalNumberOfValidModules);
  ATH_MSG_INFO("Total number of bad module identifiers is " << totalBad);
 
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode SCT_ConfigurationCondAlg::finalize ( )

finaloverridevirtual

Definition at line 434 of file SCT_ConfigurationCondAlg.cxx.

                                              {
  ATH_MSG_DEBUG("finalize " << name());
  return StatusCode::SUCCESS;
}

getStripId()

Identifier SCT_ConfigurationCondAlg::getStripId ( const unsigned int truncatedSerialNumber, const unsigned int chipNumber, const unsigned int stripNumber, const InDetDD::SiDetectorElementCollection * elements, const EventContext & ctx ) const

private

Definition at line 400 of file SCT_ConfigurationCondAlg.cxx.

                                                                                                                        {
  Identifier waferId;
  const Identifier invalidIdentifier; //initialiser creates invalid Id
  unsigned int strip{0};
  IdentifierHash waferHash;
  if (not m_cablingTool) {
    ATH_MSG_FATAL("The cabling tool pointer is zero.");
    return invalidIdentifier;
  }
  // If the chip is 0-5 we are in side 0, otherwise in side 1. 'getHash' only 
  // returns the side 0 hash, so we use the helper for side 1
 
  if (chipNumber<6) {
    waferHash = m_cablingTool->getHashFromSerialNumber(truncatedSerialNumber, ctx);
    strip = chipNumber * stripsPerChip + stripNumber;
    if (waferHash.is_valid()) waferId = m_pHelper->wafer_id(waferHash);
  } else {
    m_pHelper->get_other_side(m_cablingTool->getHashFromSerialNumber(truncatedSerialNumber, ctx), waferHash);
    strip = (chipNumber - 6) * stripsPerChip + stripNumber;
    if (waferHash.is_valid()) waferId = m_pHelper->wafer_id(waferHash);
  }
 
  if (not waferId.is_valid()) return invalidIdentifier;
 
  const InDetDD::SiDetectorElement* pElement{elements->getDetectorElement(waferHash)};
  if (pElement==nullptr) {
    ATH_MSG_FATAL("Element pointer is nullptr in 'getStripId' method");
    return invalidIdentifier;
  }
  strip = (pElement->swapPhiReadoutDirection()) ? (lastStrip-strip) : strip;
  return m_pHelper->strip_id(waferId, strip);
}

initialize()

StatusCode SCT_ConfigurationCondAlg::initialize ( )

finaloverridevirtual

Definition at line 35 of file SCT_ConfigurationCondAlg.cxx.

                                                {
  ATH_MSG_DEBUG("initialize " << name());
 
  // SCT cabling tool
  ATH_CHECK(m_cablingTool.retrieve());
 
  ATH_CHECK(detStore()->retrieve(m_pHelper, "SCT_ID"));
 
  // Check conditions folder names
  if ((m_readKeyChannel.key()!=s_coolChannelFolderName) and
      (m_readKeyChannel.key()!=s_coolChannelFolderName2) and
      (m_readKeyChannel.key()!=s_coolChannelFolderName2Slim)) {
    ATH_MSG_FATAL(m_readKeyChannel.key() << " is incorrect.");
    return StatusCode::FAILURE;
  }
  if ((m_readKeyModule.key()!=s_coolModuleFolderName) and (m_readKeyModule.key()!=s_coolModuleFolderName2)) {
    ATH_MSG_FATAL(m_readKeyModule.key() << " is incorrect.");
    return StatusCode::FAILURE;
  }
  if ((m_readKeyMur.key()!=s_coolMurFolderName) and (m_readKeyMur.key()!=s_coolMurFolderName2)) {
    ATH_MSG_FATAL(m_readKeyMur.key() << " is incorrect.");
    return StatusCode::FAILURE;
  }
 
  // Read Cond Handle
  ATH_CHECK(m_readKeyChannel.initialize());
  ATH_CHECK(m_readKeyModule.initialize());
  ATH_CHECK(m_readKeyMur.initialize());
  ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
  // Write Cond Handle
  ATH_CHECK(m_writeKey.initialize());
 
  ATH_CHECK(m_readoutTool.retrieve());
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

isReEntrant()

virtual bool SCT_ConfigurationCondAlg::isReEntrant ( ) const

inlinefinaloverridevirtual

Definition at line 38 of file SCT_ConfigurationCondAlg.h.

{ return false; }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_cablingTool

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

private

Handle on SCT cabling service.

Definition at line 64 of file SCT_ConfigurationCondAlg.h.

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

m_condSvc

ServiceHandle<ICondSvc> SCT_ConfigurationCondAlg::m_condSvc {this, "CondSvc", "CondSvc"}

private

Definition at line 63 of file SCT_ConfigurationCondAlg.h.

{this, "CondSvc", "CondSvc"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_pHelper

const SCT_ID* SCT_ConfigurationCondAlg::m_pHelper {nullptr}

private

ID helper for SCT.

Definition at line 66 of file SCT_ConfigurationCondAlg.h.

{nullptr}; 

m_readKeyChannel

SG::ReadCondHandleKey<CondAttrListVec> SCT_ConfigurationCondAlg::m_readKeyChannel {this, "ReadKeyChannel", "/SCT/DAQ/Config/Chip", "Key of input (raw) conditions folder of chips"}

private

Definition at line 58 of file SCT_ConfigurationCondAlg.h.

{this, "ReadKeyChannel", "/SCT/DAQ/Config/Chip", "Key of input (raw) conditions folder of chips"};

m_readKeyModule

SG::ReadCondHandleKey<CondAttrListVec> SCT_ConfigurationCondAlg::m_readKeyModule {this, "ReadKeyModule", "/SCT/DAQ/Config/Module", "Key of input (raw) conditions folder of modules"}

private

Definition at line 59 of file SCT_ConfigurationCondAlg.h.

{this, "ReadKeyModule", "/SCT/DAQ/Config/Module", "Key of input (raw) conditions folder of modules"};

m_readKeyMur

SG::ReadCondHandleKey<CondAttrListVec> SCT_ConfigurationCondAlg::m_readKeyMur {this, "ReadKeyMur", "/SCT/DAQ/Config/MUR", "Key of input (raw) conditions folder of Murs"}

private

Definition at line 60 of file SCT_ConfigurationCondAlg.h.

{this, "ReadKeyMur", "/SCT/DAQ/Config/MUR", "Key of input (raw) conditions folder of Murs"};

m_readoutTool

ToolHandle<ISCT_ReadoutTool> SCT_ConfigurationCondAlg::m_readoutTool {this, "SCT_ReadoutTool", "SCT_ReadoutTool", "Handle on readout tool"}

private

Handle on readout tool.

Definition at line 65 of file SCT_ConfigurationCondAlg.h.

{this, "SCT_ReadoutTool", "SCT_ReadoutTool", "Handle on readout tool"}; 

m_SCTDetEleCollKey

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

private

Definition at line 61 of file SCT_ConfigurationCondAlg.h.

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

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeKey

SG::WriteCondHandleKey<SCT_ConfigurationCondData> SCT_ConfigurationCondAlg::m_writeKey {this, "WriteKey", "SCT_ConfigurationCondData", "Key of output (derived) conditions data"}

private

Definition at line 62 of file SCT_ConfigurationCondAlg.h.

{this, "WriteKey", "SCT_ConfigurationCondData", "Key of output (derived) conditions data"};

s_coolChannelFolderName

const std::string SCT_ConfigurationCondAlg::s_coolChannelFolderName {"/SCT/DAQ/Configuration/Chip"}

staticprivate

Definition at line 18 of file SCT_ConfigurationCondAlg.h.

s_coolChannelFolderName2

const std::string SCT_ConfigurationCondAlg::s_coolChannelFolderName2 {"/SCT/DAQ/Config/Chip"}

staticprivate

Definition at line 23 of file SCT_ConfigurationCondAlg.h.

s_coolChannelFolderName2Slim

const std::string SCT_ConfigurationCondAlg::s_coolChannelFolderName2Slim {"/SCT/DAQ/Config/ChipSlim"}

staticprivate

Definition at line 28 of file SCT_ConfigurationCondAlg.h.

s_coolModuleFolderName

const std::string SCT_ConfigurationCondAlg::s_coolModuleFolderName {"/SCT/DAQ/Configuration/Module"}

staticprivate

Definition at line 19 of file SCT_ConfigurationCondAlg.h.

s_coolModuleFolderName2

const std::string SCT_ConfigurationCondAlg::s_coolModuleFolderName2 {"/SCT/DAQ/Config/Module"}

staticprivate

Definition at line 24 of file SCT_ConfigurationCondAlg.h.

s_coolMurFolderName

const std::string SCT_ConfigurationCondAlg::s_coolMurFolderName {"/SCT/DAQ/Configuration/MUR"}

staticprivate

Definition at line 20 of file SCT_ConfigurationCondAlg.h.

s_coolMurFolderName2

const std::string SCT_ConfigurationCondAlg::s_coolMurFolderName2 {"/SCT/DAQ/Config/MUR"}

staticprivate

Definition at line 25 of file SCT_ConfigurationCondAlg.h.

---

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

• SCT_ConfigurationCondAlg.h
• SCT_ConfigurationCondAlg.cxx