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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const std::string	s_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()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< 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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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));
   //coverity[copy_constructor_call]
   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] = std::move(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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

190{this, "BeginRun", IOVTime::MINRUN};

IOVTime::MINRUN

static constexpr uint32_t MINRUN

Definition IOVTime.h:44

◆ m_BSErrRecorded

bool SCTCalibWriteTool::m_BSErrRecorded {false}

private

Definition at line 212 of file SCTCalibWriteTool.h.

212{false};

◆ m_deadChipRecorded

bool SCTCalibWriteTool::m_deadChipRecorded {false}

private

Definition at line 208 of file SCTCalibWriteTool.h.

208{false};

◆ m_deadStripRecorded

bool SCTCalibWriteTool::m_deadStripRecorded {false}

private

Definition at line 207 of file SCTCalibWriteTool.h.

207{false};

◆ m_defectRecorded

bool SCTCalibWriteTool::m_defectRecorded {false}

private

Definition at line 206 of file SCTCalibWriteTool.h.

206{false};

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

209{false};

◆ m_endRun

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

private

Definition at line 191 of file SCTCalibWriteTool.h.

191{this, "EndRun", IOVTime::MAXRUN};

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

213{false};

◆ m_manualiov

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

private

Definition at line 188 of file SCTCalibWriteTool.h.

188{this, "ManualIOV", true};

◆ m_mutex

std::mutex SCTCalibWriteTool::m_mutex {}

mutableprivate

Definition at line 174 of file SCTCalibWriteTool.h.

174{};

◆ m_noRecorded

bool SCTCalibWriteTool::m_noRecorded {false}

private

Definition at line 210 of file SCTCalibWriteTool.h.

210{false};

◆ m_pHelper

const SCT_ID* SCTCalibWriteTool::m_pHelper {nullptr}

private

Definition at line 214 of file SCTCalibWriteTool.h.

214{nullptr};

◆ m_RawOccuRecorded

bool SCTCalibWriteTool::m_RawOccuRecorded {false}

private

Definition at line 211 of file SCTCalibWriteTool.h.

211{false};

◆ m_readWriteCool

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

private

Definition at line 186 of file SCTCalibWriteTool.h.

186{this, "ReadWriteCool", true};

◆ m_regIOV

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

private

Definition at line 185 of file SCTCalibWriteTool.h.

185{this, "RegisterIOV", true};

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

203{nullptr};

◆ m_streamName

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

private

Definition at line 192 of file SCTCalibWriteTool.h.

192{this, "StreamName", "SCTCalibStream"};

◆ m_tagID4BSErrors

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

private

Definition at line 199 of file SCTCalibWriteTool.h.

199{this, "TagID4BSErrors", ""};

◆ m_tagID4DeadChips

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

private

Definition at line 195 of file SCTCalibWriteTool.h.

195{this, "TagID4DeadChips", ""};

◆ m_tagID4DeadStrips

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

private

Definition at line 194 of file SCTCalibWriteTool.h.

194{this, "TagID4DeadStrips", ""};

◆ m_tagID4Efficiency

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

private

Definition at line 196 of file SCTCalibWriteTool.h.

196{this, "TagID4Efficiency", ""};

◆ m_tagID4LorentzAngle

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

private

Definition at line 200 of file SCTCalibWriteTool.h.

200{this, "TagID4LorentzAngle", ""};

◆ m_tagID4NoiseOccupancy

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

private

Definition at line 197 of file SCTCalibWriteTool.h.

197{this, "TagID4NoiseOccupancy", ""};

◆ m_tagID4NoisyStrips

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

private

Definition at line 193 of file SCTCalibWriteTool.h.

193{this, "TagID4NoisyStrips", ""};

◆ m_tagID4RawOccupancy

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

private

Definition at line 198 of file SCTCalibWriteTool.h.

198{this, "TagID4RawOccupancy", ""};

◆ m_twoStepWriteReg

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

private

Definition at line 187 of file SCTCalibWriteTool.h.

187{this, "TwoStepWriteReg", false};

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

189{this, "Version", 0};

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

184{this, "WriteCondObjs", true};

◆ s_BSErrFolderName

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

staticprivate

Definition at line 39 of file SCTCalibWriteTool.h.

◆ s_deadChipFolderName

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

staticprivate

Definition at line 35 of file SCTCalibWriteTool.h.

◆ s_deadStripFolderName

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

staticprivate

Definition at line 34 of file SCTCalibWriteTool.h.

◆ s_defectFolderName

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

staticprivate

Definition at line 33 of file SCTCalibWriteTool.h.

◆ s_effFolderName

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

staticprivate

Definition at line 36 of file SCTCalibWriteTool.h.

◆ s_LAFolderName

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

staticprivate

Definition at line 40 of file SCTCalibWriteTool.h.

◆ s_noFolderName

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

staticprivate

Definition at line 37 of file SCTCalibWriteTool.h.

◆ s_RawOccuFolderName

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

staticprivate

Definition at line 38 of file SCTCalibWriteTool.h.

◆ s_separator

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

staticprivate

Definition at line 32 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()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ getAttrListCollectionByFolder()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ 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

◆ m_defectRecorded

◆ m_detStore

◆ m_effRecorded

◆ m_endRun

◆ m_evtStore

◆ m_IOVDbSvc

◆ m_LARecorded

◆ m_manualiov

◆ m_mutex

◆ m_noRecorded