Tool to test writing conditions data and reading them back. More...

#include <SCTCalibWriteTool.h>

Inheritance diagram for SCTCalibWriteTool:

Collaboration diagram for SCTCalibWriteTool:

Public Member Functions
	SCTCalibWriteTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize () override

std::string	addDefect (const std::string &defectlist, const int defectBeginChannel, const int defectEndChannel) const

std::string	addNumber (const std::string &numStr, const unsigned long long number) const

std::string	createDefectString (const int defectBeginChannel, const int defectEndChannel) const

StatusCode createCondObjects	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const std::string &defectType, const float threshold, const std::string &defectList) const

StatusCode createListStrip	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const std::string &defectType, const float threshold, const std::string &defectList) const

StatusCode createListChip	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const std::string &defectType, const float threshold, const std::string &defectList) const

StatusCode createListEff	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const float eff) const

StatusCode createListNO	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const float noise_occ) const

StatusCode createListRawOccu	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const float raw_occu) const

StatusCode createListBSErr	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const std::string &errorList, const std::string &probList) const

StatusCode createListLA	ATLAS_NOT_THREAD_SAFE (const Identifier &wafer_id, const SCT_ID *m_sctId, const int samplesize, const int module, const float lorentz, const float err_lorentz, const float chisq, const float fitParam_a, const float err_a, const float fitParam_b, const float err_b, const float fitParam_sigma, const float err_sigma, const float MCW, const float err_MCW) const

StatusCode	wrapUpNoisyChannel ()

StatusCode	wrapUpDeadStrips ()

StatusCode	wrapUpDeadChips ()

StatusCode	wrapUpEfficiency ()

StatusCode	wrapUpNoiseOccupancy ()

StatusCode	wrapUpRawOccupancy ()

StatusCode	wrapUpBSErrors ()

StatusCode	wrapUpLorentzAngle ()

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	sysInitialize () override
	Perform system initialization for an algorithm. 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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	stringToInt (const std::string &s) const

StatusCode	streamOutCondObjects (const std::string &foldername)

StatusCode	streamOutCondObjectsWithErrMsg (const std::string &foldername)

StatusCode	registerCondObjects (const std::string &foldername, const std::string &tagname) const

StatusCode	recordAndStream (std::unique_ptr< CondAttrListCollection > pCollection, const std::string &foldername, bool &flag)

StatusCode	registerCondObjectsWithErrMsg (const std::string &foldername, const std::string &tagname) const

coral::AttributeListSpecification *	createBasicDbSpec (const bool capsFormat) const

void	setBasicValues (coral::AttributeList &attrList, const Identifier &wafer_id, const int samplesize, const SCT_ID *m_sctId, const bool capsFormat) const

unsigned int	computeIstrip4moncond (const Identifier &elementId) const

const CondAttrListCollection *	getAttrListCollectionByFolder (const std::string &) 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
std::mutex	m_mutex {}

std::map< const std::string, const CondAttrListCollection * > m_attrListCollectionMap	ATLAS_THREAD_SAFE

std::unique_ptr< CondAttrListCollection >	m_attrListColl

std::unique_ptr< CondAttrListCollection >	m_attrListColl_deadStrip

std::unique_ptr< CondAttrListCollection >	m_attrListColl_deadChip

std::unique_ptr< CondAttrListCollection >	m_attrListColl_eff

std::unique_ptr< CondAttrListCollection >	m_attrListColl_no

std::unique_ptr< CondAttrListCollection >	m_attrListColl_RawOccu

std::unique_ptr< CondAttrListCollection >	m_attrListColl_BSErr

std::unique_ptr< CondAttrListCollection >	m_attrListColl_LA

BooleanProperty	m_writeCondObjs {this, "WriteCondObjs", true}

BooleanProperty	m_regIOV {this, "RegisterIOV", true}

BooleanProperty	m_readWriteCool {this, "ReadWriteCool", true}

BooleanProperty	m_twoStepWriteReg {this, "TwoStepWriteReg", false}

BooleanProperty	m_manualiov {this, "ManualIOV", true}

IntegerProperty	m_version {this, "Version", 0}

IntegerProperty	m_beginRun {this, "BeginRun", IOVTime::MINRUN}

IntegerProperty	m_endRun {this, "EndRun", IOVTime::MAXRUN}

StringProperty	m_streamName {this, "StreamName", "SCTCalibStream"}

StringProperty	m_tagID4NoisyStrips {this, "TagID4NoisyStrips", ""}

StringProperty	m_tagID4DeadStrips {this, "TagID4DeadStrips", ""}

StringProperty	m_tagID4DeadChips {this, "TagID4DeadChips", ""}

StringProperty	m_tagID4Efficiency {this, "TagID4Efficiency", ""}

StringProperty	m_tagID4NoiseOccupancy {this, "TagID4NoiseOccupancy", ""}

StringProperty	m_tagID4RawOccupancy {this, "TagID4RawOccupancy", ""}

StringProperty	m_tagID4BSErrors {this, "TagID4BSErrors", ""}

StringProperty	m_tagID4LorentzAngle {this, "TagID4LorentzAngle", ""}

ServiceHandle< IIOVRegistrationSvc >	m_regSvc

ToolHandle< IAthenaOutputStreamTool >	m_streamer {nullptr}

ServiceHandle< IIOVDbSvc >	m_IOVDbSvc

bool	m_defectRecorded {false}

bool	m_deadStripRecorded {false}

bool	m_deadChipRecorded {false}

bool	m_effRecorded {false}

bool	m_noRecorded {false}

bool	m_RawOccuRecorded {false}

bool	m_BSErrRecorded {false}

bool	m_LARecorded {false}

const SCT_ID *	m_pHelper {nullptr}

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_separator {"-"}

static const std::string	s_defectFolderName {"/SCT/Derived/Monitoring"}

static const std::string	s_deadStripFolderName {"/SCT/Derived/DeadStrips"}

static const std::string	s_deadChipFolderName {"/SCT/Derived/DeadChips"}

static const std::string	s_effFolderName {"/SCT/Derived/Efficiency"}

static const std::string	s_noFolderName {"/SCT/Derived/NoiseOccupancy"}

static const std::string	s_RawOccuFolderName {"/SCT/Derived/RawOccupancy"}

static const std::string	s_BSErrFolderName {"/SCT/Derived/BSErrorsRun2"}

static const std::string	s_LAFolderName {"/SCT/Derived/LorentzAngleRun2_v2"}

Detailed Description

Tool to test writing conditions data and reading them back.

Definition at line 51 of file SCTCalibWriteTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ SCTCalibWriteTool()

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

Definition at line 45 of file SCTCalibWriteTool.cxx.

                                                                                                            :
    AthAlgTool(type, name, parent),
    m_regSvc("IOVRegistrationSvc", name),
    m_streamer(((m_version == 0) ? "AthenaOutputStreamTool" : "AthenaPoolOutputStreamTool"), this),
    m_IOVDbSvc("IOVDbSvc", name)
 {
 }

Member Function Documentation

◆ addDefect()

std::string SCTCalibWriteTool::addDefect	(	const std::string &	defectlist,
		const int	defectBeginChannel,
		const int	defectEndChannel
	)		const

Definition at line 103 of file SCTCalibWriteTool.cxx.

                                                                                                                         {
    // check size of defect list,
    // if it is empty then use createDefectString to make first entry.
    if (defectlist.empty()) return createDefectString(defectBeginChannel, defectEndChannel);
  
    // adding another Defect in DefectList
    std::ostringstream defect;
    defect << defectlist << " " << defectBeginChannel;
    if (defectBeginChannel==defectEndChannel) {
       defect << " ";
    } else {
       defect << "-" << defectEndChannel << " ";
    }
    return defect.str();
 }

◆ addNumber()

std::string SCTCalibWriteTool::addNumber	(	const std::string &	numStr,
		const unsigned long long	number
	)		const

Definition at line 136 of file SCTCalibWriteTool.cxx.

                                                                                            {
    std::ostringstream num_string;
    // if it is empty then use createDefectString to make first entry.
    if (numStr.empty()) {
       num_string << number;
    } else { // adding another number to numStr
       num_string << numStr << " " << number;
    }
    return num_string.str();
 }

◆ ATLAS_NOT_THREAD_SAFE() [1/8]

StatusCode createListEff SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const float	eff
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [2/8]

StatusCode createListNO SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const float	noise_occ
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [3/8]

StatusCode createListRawOccu SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const float	raw_occu
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [4/8]

StatusCode createListLA SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const int	module,
		const float	lorentz,
		const float	err_lorentz,
		const float	chisq,
		const float	fitParam_a,
		const float	err_a,
		const float	fitParam_b,
		const float	err_b,
		const float	fitParam_sigma,
		const float	err_sigma,
		const float	MCW,
		const float	err_MCW
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [5/8]

StatusCode createCondObjects SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const std::string &	defectType,
		const float	threshold,
		const std::string &	defectList
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [6/8]

StatusCode createListStrip SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const std::string &	defectType,
		const float	threshold,
		const std::string &	defectList
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [7/8]

StatusCode createListChip SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const std::string &	defectType,
		const float	threshold,
		const std::string &	defectList
	)		const

◆ ATLAS_NOT_THREAD_SAFE() [8/8]

StatusCode createListBSErr SCTCalibWriteTool::ATLAS_NOT_THREAD_SAFE	(	const Identifier &	wafer_id,
		const SCT_ID *	m_sctId,
		const int	samplesize,
		const std::string &	errorList,
		const std::string &	probList
	)		const

◆ computeIstrip4moncond()

unsigned int SCTCalibWriteTool::computeIstrip4moncond ( const Identifier & elementId ) const

private

Definition at line 90 of file SCTCalibWriteTool.cxx.

                                                                           {
    unsigned int iiside{static_cast<unsigned int>(m_pHelper->side(elementId))};
    unsigned int iistrip{static_cast<unsigned int>(m_pHelper->strip(elementId))};
    return 768*iiside + iistrip;
 }

◆ createBasicDbSpec()

coral::AttributeListSpecification * SCTCalibWriteTool::createBasicDbSpec ( const bool capsFormat ) const

private

Definition at line 634 of file SCTCalibWriteTool.cxx.

                                                                 {
    coral::AttributeListSpecification* attrSpec{new coral::AttributeListSpecification{}};
    const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
    attrSpec->extend("SampleSize", "int");
    attrSpec->extend(becName, "int");
    attrSpec->extend("Layer", "int");
    attrSpec->extend("Eta", "int");
    attrSpec->extend("Phi", "int");
    return attrSpec;
 }

◆ createDefectString()

std::string SCTCalibWriteTool::createDefectString	(	const int	defectBeginChannel,
		const int	defectEndChannel
	)		const

Definition at line 122 of file SCTCalibWriteTool.cxx.

                                                                                                     {
    std::ostringstream defect;
    defect << " " << defectBeginChannel;
    if (defectBeginChannel!=defectEndChannel) {
       defect << "-" << defectEndChannel;
    }
    defect << " ";
    return defect.str();
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ getAttrListCollectionByFolder()

const CondAttrListCollection * SCTCalibWriteTool::getAttrListCollectionByFolder ( const std::string & foldername ) const

private

Definition at line 413 of file SCTCalibWriteTool.cxx.

                                                                                   {
    std::lock_guard<std::mutex> lock{m_mutex};
    // trying to find the pointer in the hashmap
    // if it exists, return it, otherwise put it in.
    const CondAttrListCollection* attrListCollection{nullptr};
    if (m_attrListCollectionMap.count(foldername) == 0) {
       if (detStore()->retrieve(attrListCollection, foldername).isFailure()) {
          ATH_MSG_ERROR("Could not retrieve " << foldername);
          return nullptr;
       }
       m_attrListCollectionMap.insert(make_pair(foldername, attrListCollection));
    } else {
       attrListCollection = m_attrListCollectionMap[foldername];
    }
    return attrListCollection;
 }

◆ initialize()

StatusCode SCTCalibWriteTool::initialize ( )

overridevirtual

Definition at line 56 of file SCTCalibWriteTool.cxx.

 {
  
    ATH_MSG_DEBUG("in SCTCalibWriteTool::initialize start");
  
    ATH_CHECK( detStore()->retrieve(m_pHelper,"SCT_ID") );
  
    // ------------------------------------------------------------
    // The following is required for writing out something to COOL
  
    // CondAttrListCollection to store table temporarily
    m_attrListColl = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_deadStrip = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_deadChip = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_eff = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_no = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_RawOccu = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_BSErr = std::make_unique<CondAttrListCollection>(true);
    m_attrListColl_LA = std::make_unique<CondAttrListCollection>(true);
  
    // Get the IOVRegistrationSvc when needed
    if (m_regIOV) {
       ATH_CHECK( m_regSvc.retrieve() );
    }
  
    // Retrieve IOVDb service
    ATH_CHECK( m_IOVDbSvc.retrieve() );
  
    return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

◆ recordAndStream()

StatusCode SCTCalibWriteTool::recordAndStream	(	std::unique_ptr< CondAttrListCollection >	pCollection,
		const std::string &	foldername,
		bool &	flag
	)

private

Definition at line 618 of file SCTCalibWriteTool.cxx.

                                                                                                                             {
    ATH_MSG_DEBUG("recordAndStream start " << foldername);
    if (m_writeCondObjs) {
       if (detStore()->record(std::move(pCollection), foldername).isFailure()) {
          ATH_MSG_ERROR("Could not record "<<foldername);
          return StatusCode::FAILURE;
       }
       flag=true;
       if (streamOutCondObjectsWithErrMsg(s_defectFolderName).isFailure()) return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
 }

◆ registerCondObjects()

StatusCode SCTCalibWriteTool::registerCondObjects	(	const std::string &	foldername,
		const std::string &	tagname
	)		const

private

Definition at line 551 of file SCTCalibWriteTool.cxx.

                                                                                                  {
    // Register the IOV DB with the conditions data written out
    ATH_MSG_DEBUG("registerCondObjects start");
    if (m_readWriteCool) {
       // Can only write out AttrList's if this is NOT write and reg in two steps
       if (!m_twoStepWriteReg) {
          // Using COOL, write out attrlist and collection of attrlists
          // attrlist collection
          StatusCode sc;
          unsigned int beginRun;
          unsigned int endRun;
          if (!m_manualiov) {
  
             const EventContext& ctx = Gaudi::Hive::currentContext();
             beginRun = ctx.eventID().run_number();
             endRun = beginRun;
  
          } else {
             beginRun = m_beginRun;
             if ( m_endRun != -1 ) endRun = m_endRun;
             else                  endRun = IOVTime::MAXRUN;
          }
  
          unsigned int beginLB{IOVTime::MINEVENT};
          unsigned int endLB{IOVTime::MAXEVENT};
  
          ATH_MSG_DEBUG("registerCondObjects: registerCondObjects middle");
  
          if (not tagname.empty()) {
             ATH_MSG_DEBUG("registerCondObjects: registerCondObjects before registerIOV 1");
             ATH_MSG_DEBUG("registerCondObjects: foldername, tagname, beginRun, endRun, beginLB, endLB: " << foldername << ", " << tagname << ", " << beginRun << ", " << endRun << ", " << beginLB << ", " << endLB);
             sc = m_regSvc->registerIOV("CondAttrListCollection", foldername, tagname, beginRun, endRun, beginLB, endLB);
             ATH_MSG_DEBUG("registerCondObjects after registerIOV 1");
          } else {
             ATH_MSG_DEBUG("registerCondObjects before registerIOV 2");
             ATH_MSG_DEBUG("registerCondObjects: foldername, beginRun, endRun, beginLB, endLB: " << foldername << ", " << beginRun << ", " << endRun << ", " << beginLB << ", " << endLB);
             sc = m_regSvc->registerIOV("CondAttrListCollection", foldername, "", beginRun, endRun, beginLB, endLB);
             ATH_MSG_DEBUG("registerCondObjects after registerIOV 2");
          }
          if (sc.isFailure()) {
             ATH_MSG_ERROR("registerCondObjects: Could not register in IOV DB for CondAttrListCollection");
             return StatusCode::FAILURE;
          }
       }
    }
  
    ATH_MSG_DEBUG("registerCondObjects end");
  
    return StatusCode::SUCCESS;
 }

◆ registerCondObjectsWithErrMsg()

StatusCode SCTCalibWriteTool::registerCondObjectsWithErrMsg	(	const std::string &	foldername,
		const std::string &	tagname
	)		const

private

Definition at line 605 of file SCTCalibWriteTool.cxx.

                                                                                                            {
    if (m_regIOV) {
       if (registerCondObjects(foldername,tagname).isFailure()) {
          ATH_MSG_ERROR("registerCondObjectsWithErrMsg: Could not register " << foldername);
          return StatusCode::FAILURE;
       }
    }
    return StatusCode::SUCCESS;
 }

◆ 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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ setBasicValues()

void SCTCalibWriteTool::setBasicValues	(	coral::AttributeList &	attrList,
		const Identifier &	wafer_id,
		const int	samplesize,
		const SCT_ID *	m_sctId,
		const bool	capsFormat
	)		const

private

Definition at line 648 of file SCTCalibWriteTool.cxx.

                                                                                                                                                                   {
    int eta{sctId->eta_module(wafer_id)};
    int phi{sctId->phi_module(wafer_id)};
    int barrel_ec{sctId->barrel_ec(wafer_id)};
    int layer{sctId->layer_disk(wafer_id)};
    //
    const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
    attrList["SampleSize"].setValue(static_cast<int>(samplesize));
    attrList[becName].setValue(static_cast<int>(barrel_ec));
    attrList["Layer"].setValue(static_cast<int>(layer));
    attrList["Eta"].setValue(static_cast<int>(eta));
    attrList["Phi"].setValue(static_cast<int>(phi));
  
    return;
 }

◆ streamOutCondObjects()

StatusCode SCTCalibWriteTool::streamOutCondObjects ( const std::string & foldername )

private

Definition at line 512 of file SCTCalibWriteTool.cxx.

                                                                    {
    ATH_MSG_DEBUG("streamOutCondObjects start");
    if (m_streamer->connectOutput(m_streamName).isFailure()) {
       ATH_MSG_ERROR("Could not connect stream to output");
       return( StatusCode::FAILURE);
    }
    IAthenaOutputStreamTool::TypeKeyPairs typeKeys{1};
    if (m_readWriteCool) {
       IAthenaOutputStreamTool::TypeKeyPair attrCollPair{"CondAttrListCollection", foldername};
       typeKeys[0] = attrCollPair;
    }
  
    if (m_streamer->streamObjects(typeKeys).isFailure()) {
       ATH_MSG_ERROR("Could not stream out AttributeLists");
       return StatusCode::FAILURE;
    }
  
    if (m_streamer->commitOutput().isFailure()) {
       ATH_MSG_ERROR("Could not commit output stream");
       return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
 }

◆ streamOutCondObjectsWithErrMsg()

StatusCode SCTCalibWriteTool::streamOutCondObjectsWithErrMsg ( const std::string & foldername )

private

Definition at line 539 of file SCTCalibWriteTool.cxx.

                                                                              {
    ATH_MSG_DEBUG("streamOutCondObjectsWithErrMsg: foldername " << foldername);
    if (streamOutCondObjects(foldername).isFailure()) {
       ATH_MSG_ERROR("Could not create conditions object  " << foldername);
       return StatusCode::FAILURE;
    }
    return StatusCode::SUCCESS;
 }

◆ stringToInt()

int SCTCalibWriteTool::stringToInt ( const std::string & s ) const

private

Definition at line 433 of file SCTCalibWriteTool.cxx.

                                                        {
    return atoi(s.c_str());
 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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);
       }
     }
   }

◆ wrapUpBSErrors()

StatusCode SCTCalibWriteTool::wrapUpBSErrors ( )

Definition at line 494 of file SCTCalibWriteTool.cxx.

                                   {
    if (recordAndStream(std::move(m_attrListColl_BSErr), s_BSErrFolderName, m_BSErrRecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_BSErrFolderName, m_tagID4BSErrors).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpDeadChips()

StatusCode SCTCalibWriteTool::wrapUpDeadChips ( )

Definition at line 458 of file SCTCalibWriteTool.cxx.

                                    {
    if (recordAndStream(std::move(m_attrListColl_deadChip), s_deadChipFolderName, m_deadChipRecorded).isFailure())  return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_deadChipFolderName, m_tagID4DeadChips).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpDeadStrips()

StatusCode SCTCalibWriteTool::wrapUpDeadStrips ( )

Definition at line 449 of file SCTCalibWriteTool.cxx.

                                     {
    if (recordAndStream(std::move(m_attrListColl_deadStrip), s_deadStripFolderName, m_deadStripRecorded).isFailure()) return  StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_deadStripFolderName, m_tagID4DeadStrips).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpEfficiency()

StatusCode SCTCalibWriteTool::wrapUpEfficiency ( )

Definition at line 467 of file SCTCalibWriteTool.cxx.

                                     {
    if (recordAndStream(std::move(m_attrListColl_eff), s_effFolderName, m_effRecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_effFolderName, m_tagID4Efficiency).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpLorentzAngle()

StatusCode SCTCalibWriteTool::wrapUpLorentzAngle ( )

Definition at line 503 of file SCTCalibWriteTool.cxx.

                                       {
    if (recordAndStream(std::move(m_attrListColl_LA), s_LAFolderName, m_LARecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_LAFolderName, m_tagID4LorentzAngle).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpNoiseOccupancy()

StatusCode SCTCalibWriteTool::wrapUpNoiseOccupancy ( )

Definition at line 476 of file SCTCalibWriteTool.cxx.

                                         {
    if (recordAndStream(std::move(m_attrListColl_no), s_noFolderName, m_noRecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_noFolderName, m_tagID4NoiseOccupancy).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpNoisyChannel()

StatusCode SCTCalibWriteTool::wrapUpNoisyChannel ( )

Definition at line 440 of file SCTCalibWriteTool.cxx.

                                       {
    if (recordAndStream(std::move(m_attrListColl), s_defectFolderName, m_defectRecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_defectFolderName, m_tagID4NoisyStrips).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

◆ wrapUpRawOccupancy()

StatusCode SCTCalibWriteTool::wrapUpRawOccupancy ( )

Definition at line 485 of file SCTCalibWriteTool.cxx.

                                       {
    if (recordAndStream(std::move(m_attrListColl_RawOccu), s_RawOccuFolderName, m_RawOccuRecorded).isFailure()) return StatusCode::FAILURE;
    if (registerCondObjectsWithErrMsg(s_RawOccuFolderName, m_tagID4RawOccupancy).isFailure()) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::map<const std::string, const CondAttrListCollection*> m_attrListCollectionMap SCTCalibWriteTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 175 of file SCTCalibWriteTool.h.

◆ m_attrListColl

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl

private

Definition at line 176 of file SCTCalibWriteTool.h.

◆ m_attrListColl_BSErr

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_BSErr

private

Definition at line 182 of file SCTCalibWriteTool.h.

◆ m_attrListColl_deadChip

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_deadChip

private

Definition at line 178 of file SCTCalibWriteTool.h.

◆ m_attrListColl_deadStrip

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_deadStrip

private

Definition at line 177 of file SCTCalibWriteTool.h.

◆ m_attrListColl_eff

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_eff

private

Definition at line 179 of file SCTCalibWriteTool.h.

◆ m_attrListColl_LA

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_LA

private

Definition at line 183 of file SCTCalibWriteTool.h.

◆ m_attrListColl_no

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_no

private

Definition at line 180 of file SCTCalibWriteTool.h.

◆ m_attrListColl_RawOccu

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_RawOccu

private

Definition at line 181 of file SCTCalibWriteTool.h.

◆ m_beginRun

IntegerProperty SCTCalibWriteTool::m_beginRun {this, "BeginRun", IOVTime::MINRUN}

private

Definition at line 190 of file SCTCalibWriteTool.h.

◆ m_BSErrRecorded

bool SCTCalibWriteTool::m_BSErrRecorded {false}

private

Definition at line 212 of file SCTCalibWriteTool.h.

◆ m_deadChipRecorded

bool SCTCalibWriteTool::m_deadChipRecorded {false}

private

Definition at line 208 of file SCTCalibWriteTool.h.

◆ m_deadStripRecorded

bool SCTCalibWriteTool::m_deadStripRecorded {false}

private

Definition at line 207 of file SCTCalibWriteTool.h.

◆ m_defectRecorded

bool SCTCalibWriteTool::m_defectRecorded {false}

private

Definition at line 206 of file SCTCalibWriteTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_effRecorded

bool SCTCalibWriteTool::m_effRecorded {false}

private

Definition at line 209 of file SCTCalibWriteTool.h.

◆ m_endRun

IntegerProperty SCTCalibWriteTool::m_endRun {this, "EndRun", IOVTime::MAXRUN}

private

Definition at line 191 of file SCTCalibWriteTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_IOVDbSvc

ServiceHandle<IIOVDbSvc> SCTCalibWriteTool::m_IOVDbSvc

private

Definition at line 204 of file SCTCalibWriteTool.h.

◆ m_LARecorded

bool SCTCalibWriteTool::m_LARecorded {false}

private

Definition at line 213 of file SCTCalibWriteTool.h.

◆ m_manualiov

BooleanProperty SCTCalibWriteTool::m_manualiov {this, "ManualIOV", true}

private

Definition at line 188 of file SCTCalibWriteTool.h.

◆ m_mutex

std::mutex SCTCalibWriteTool::m_mutex {}

mutableprivate

Definition at line 174 of file SCTCalibWriteTool.h.

◆ m_noRecorded

bool SCTCalibWriteTool::m_noRecorded {false}

private

Definition at line 210 of file SCTCalibWriteTool.h.

◆ m_pHelper

const SCT_ID* SCTCalibWriteTool::m_pHelper {nullptr}

private

Definition at line 214 of file SCTCalibWriteTool.h.

◆ m_RawOccuRecorded

bool SCTCalibWriteTool::m_RawOccuRecorded {false}

private

Definition at line 211 of file SCTCalibWriteTool.h.

◆ m_readWriteCool

BooleanProperty SCTCalibWriteTool::m_readWriteCool {this, "ReadWriteCool", true}

private

Definition at line 186 of file SCTCalibWriteTool.h.

◆ m_regIOV

BooleanProperty SCTCalibWriteTool::m_regIOV {this, "RegisterIOV", true}

private

Definition at line 185 of file SCTCalibWriteTool.h.

◆ m_regSvc

ServiceHandle<IIOVRegistrationSvc> SCTCalibWriteTool::m_regSvc

private

Definition at line 202 of file SCTCalibWriteTool.h.

◆ m_streamer

ToolHandle<IAthenaOutputStreamTool> SCTCalibWriteTool::m_streamer {nullptr}

private

Definition at line 203 of file SCTCalibWriteTool.h.

◆ m_streamName

StringProperty SCTCalibWriteTool::m_streamName {this, "StreamName", "SCTCalibStream"}

private

Definition at line 192 of file SCTCalibWriteTool.h.

◆ m_tagID4BSErrors

StringProperty SCTCalibWriteTool::m_tagID4BSErrors {this, "TagID4BSErrors", ""}

private

Definition at line 199 of file SCTCalibWriteTool.h.

◆ m_tagID4DeadChips

StringProperty SCTCalibWriteTool::m_tagID4DeadChips {this, "TagID4DeadChips", ""}

private

Definition at line 195 of file SCTCalibWriteTool.h.

◆ m_tagID4DeadStrips

StringProperty SCTCalibWriteTool::m_tagID4DeadStrips {this, "TagID4DeadStrips", ""}

private

Definition at line 194 of file SCTCalibWriteTool.h.

◆ m_tagID4Efficiency

StringProperty SCTCalibWriteTool::m_tagID4Efficiency {this, "TagID4Efficiency", ""}

private

Definition at line 196 of file SCTCalibWriteTool.h.

◆ m_tagID4LorentzAngle

StringProperty SCTCalibWriteTool::m_tagID4LorentzAngle {this, "TagID4LorentzAngle", ""}

private

Definition at line 200 of file SCTCalibWriteTool.h.

◆ m_tagID4NoiseOccupancy

StringProperty SCTCalibWriteTool::m_tagID4NoiseOccupancy {this, "TagID4NoiseOccupancy", ""}

private

Definition at line 197 of file SCTCalibWriteTool.h.

◆ m_tagID4NoisyStrips

StringProperty SCTCalibWriteTool::m_tagID4NoisyStrips {this, "TagID4NoisyStrips", ""}

private

Definition at line 193 of file SCTCalibWriteTool.h.

◆ m_tagID4RawOccupancy

StringProperty SCTCalibWriteTool::m_tagID4RawOccupancy {this, "TagID4RawOccupancy", ""}

private

Definition at line 198 of file SCTCalibWriteTool.h.

◆ m_twoStepWriteReg

BooleanProperty SCTCalibWriteTool::m_twoStepWriteReg {this, "TwoStepWriteReg", false}

private

Definition at line 187 of file SCTCalibWriteTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_version

IntegerProperty SCTCalibWriteTool::m_version {this, "Version", 0}

private

Definition at line 189 of file SCTCalibWriteTool.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeCondObjs

BooleanProperty SCTCalibWriteTool::m_writeCondObjs {this, "WriteCondObjs", true}

private

Definition at line 184 of file SCTCalibWriteTool.h.

◆ s_BSErrFolderName

const std::string SCTCalibWriteTool::s_BSErrFolderName {"/SCT/Derived/BSErrorsRun2"}

staticprivate

Definition at line 170 of file SCTCalibWriteTool.h.

◆ s_deadChipFolderName

const std::string SCTCalibWriteTool::s_deadChipFolderName {"/SCT/Derived/DeadChips"}

staticprivate

Definition at line 166 of file SCTCalibWriteTool.h.

◆ s_deadStripFolderName

const std::string SCTCalibWriteTool::s_deadStripFolderName {"/SCT/Derived/DeadStrips"}

staticprivate

Definition at line 165 of file SCTCalibWriteTool.h.

◆ s_defectFolderName

const std::string SCTCalibWriteTool::s_defectFolderName {"/SCT/Derived/Monitoring"}

staticprivate

Definition at line 164 of file SCTCalibWriteTool.h.

◆ s_effFolderName

const std::string SCTCalibWriteTool::s_effFolderName {"/SCT/Derived/Efficiency"}

staticprivate

Definition at line 167 of file SCTCalibWriteTool.h.

◆ s_LAFolderName

const std::string SCTCalibWriteTool::s_LAFolderName {"/SCT/Derived/LorentzAngleRun2_v2"}

staticprivate

Definition at line 171 of file SCTCalibWriteTool.h.

◆ s_noFolderName

const std::string SCTCalibWriteTool::s_noFolderName {"/SCT/Derived/NoiseOccupancy"}

staticprivate

Definition at line 168 of file SCTCalibWriteTool.h.

◆ s_RawOccuFolderName

const std::string SCTCalibWriteTool::s_RawOccuFolderName {"/SCT/Derived/RawOccupancy"}

staticprivate

Definition at line 169 of file SCTCalibWriteTool.h.

◆ s_separator

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

staticprivate

Definition at line 163 of file SCTCalibWriteTool.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

Constructor & Destructor Documentation

◆ SCTCalibWriteTool()

Member Function Documentation

◆ addDefect()

◆ addNumber()

◆ ATLAS_NOT_THREAD_SAFE() [1/8]

◆ ATLAS_NOT_THREAD_SAFE() [2/8]

◆ ATLAS_NOT_THREAD_SAFE() [3/8]

◆ ATLAS_NOT_THREAD_SAFE() [4/8]

◆ ATLAS_NOT_THREAD_SAFE() [5/8]

◆ ATLAS_NOT_THREAD_SAFE() [6/8]

◆ ATLAS_NOT_THREAD_SAFE() [7/8]

◆ ATLAS_NOT_THREAD_SAFE() [8/8]

◆ computeIstrip4moncond()

◆ createBasicDbSpec()

◆ createDefectString()

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

◆ extraDeps_update_handler()

◆ getAttrListCollectionByFolder()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ recordAndStream()

◆ registerCondObjects()

◆ registerCondObjectsWithErrMsg()

◆ renounce()

◆ renounceArray()

◆ setBasicValues()

◆ streamOutCondObjects()

◆ streamOutCondObjectsWithErrMsg()

◆ stringToInt()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ wrapUpBSErrors()

◆ wrapUpDeadChips()

◆ wrapUpDeadStrips()

◆ wrapUpEfficiency()

◆ wrapUpLorentzAngle()

◆ wrapUpNoiseOccupancy()

◆ wrapUpNoisyChannel()

◆ wrapUpRawOccupancy()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_attrListColl

◆ m_attrListColl_BSErr

◆ m_attrListColl_deadChip

◆ m_attrListColl_deadStrip

◆ m_attrListColl_eff

◆ m_attrListColl_LA

◆ m_attrListColl_no

◆ m_attrListColl_RawOccu

◆ m_beginRun

◆ m_BSErrRecorded

◆ m_deadChipRecorded

◆ m_deadStripRecorded