#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. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

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`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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. More...

ToolHandle< ISCT_ReadoutTool >	m_readoutTool {this, "SCT_ReadoutTool", "SCT_ReadoutTool", "Handle on readout tool"}
	Handle on readout tool. More...

const SCT_ID *	m_pHelper {nullptr}
	ID helper for SCT. More...

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

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

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.

42 {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 AthReentrantAlgorithm::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 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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 Algorithm::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 AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.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 AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

◆ isReEntrant()

virtual bool SCT_ConfigurationCondAlg::isReEntrant ( ) const

inlinefinaloverridevirtual

Definition at line 38 of file SCT_ConfigurationCondAlg.h.

38 { return false; }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::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.

◆ m_condSvc

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

private

Definition at line 63 of file SCT_ConfigurationCondAlg.h.

◆ 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 AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ s_coolChannelFolderName

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

staticprivate

Definition at line 50 of file SCT_ConfigurationCondAlg.h.

◆ s_coolChannelFolderName2

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

staticprivate

Definition at line 51 of file SCT_ConfigurationCondAlg.h.

◆ s_coolChannelFolderName2Slim

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

staticprivate

Definition at line 52 of file SCT_ConfigurationCondAlg.h.

◆ s_coolModuleFolderName

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

staticprivate

Definition at line 53 of file SCT_ConfigurationCondAlg.h.

◆ s_coolModuleFolderName2

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

staticprivate

Definition at line 54 of file SCT_ConfigurationCondAlg.h.

◆ s_coolMurFolderName

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

staticprivate

Definition at line 55 of file SCT_ConfigurationCondAlg.h.

◆ s_coolMurFolderName2

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

staticprivate

Definition at line 56 of file SCT_ConfigurationCondAlg.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ SCT_ConfigurationCondAlg()

◆ ~SCT_ConfigurationCondAlg()

Member Function Documentation

◆ cardinality()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillChannelData()

◆ fillLinkStatus()

◆ fillModuleData()

◆ filterPassed()

◆ finalize()

◆ getStripId()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ isReEntrant()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_cablingTool

◆ m_condSvc

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_pHelper

◆ m_readKeyChannel

◆ m_readKeyModule

◆ m_readKeyMur

◆ m_readoutTool

◆ m_SCTDetEleCollKey

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_writeKey

◆ s_coolChannelFolderName

◆ s_coolChannelFolderName2

◆ s_coolChannelFolderName2Slim

◆ s_coolModuleFolderName

◆ s_coolModuleFolderName2

◆ s_coolMurFolderName

◆ s_coolMurFolderName2