ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
SCTCalibWriteTool Class Reference

Algorithm 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 ~SCTCalibWriteTool ()
 
virtual StatusCode initialize ()
 
virtual StatusCode finalize ()
 
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvIF)
 
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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

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", ""}
 
IIOVRegistrationSvc * m_regSvc {nullptr}
 
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

Algorithm to test writing conditions data and reading them back.

Definition at line 57 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 53 of file SCTCalibWriteTool.cxx.

53  :
54  AthAlgTool(type, name, parent),
55  m_streamer(((m_version == 0) ? "AthenaOutputStreamTool" : "AthenaPoolOutputStreamTool"), this),
56  m_IOVDbSvc("IOVDbSvc", "SCTCalibWriteTool")
57 {
58 }

◆ ~SCTCalibWriteTool()

SCTCalibWriteTool::~SCTCalibWriteTool ( )
virtual

Definition at line 62 of file SCTCalibWriteTool.cxx.

63 {
64 }

Member Function Documentation

◆ addDefect()

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

Definition at line 152 of file SCTCalibWriteTool.cxx.

152  {
153  // check size of defect list,
154  // if it is empty then use createDefectString to make first entry.
155  if (defectlist.empty()) return createDefectString(defectBeginChannel, defectEndChannel);
156 
157  // adding another Defect in DefectList
158  std::ostringstream defect;
159  defect << defectlist << " " << defectBeginChannel;
160  if (defectBeginChannel==defectEndChannel) {
161  defect << " ";
162  } else {
163  defect << "-" << defectEndChannel << " ";
164  }
165  return defect.str();
166 }

◆ addNumber()

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

Definition at line 185 of file SCTCalibWriteTool.cxx.

185  {
186  std::ostringstream num_string;
187  // if it is empty then use createDefectString to make first entry.
188  if (numStr.empty()) {
189  num_string << number;
190  } else { // adding another number to numStr
191  num_string << numStr << " " << number;
192  }
193  return num_string.str();
194 }

◆ 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 139 of file SCTCalibWriteTool.cxx.

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

◆ createBasicDbSpec()

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

Definition at line 683 of file SCTCalibWriteTool.cxx.

683  {
684  coral::AttributeListSpecification* attrSpec{new coral::AttributeListSpecification{}};
685  const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
686  attrSpec->extend("SampleSize", "int");
687  attrSpec->extend(becName, "int");
688  attrSpec->extend("Layer", "int");
689  attrSpec->extend("Eta", "int");
690  attrSpec->extend("Phi", "int");
691  return attrSpec;
692 }

◆ createDefectString()

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

Definition at line 171 of file SCTCalibWriteTool.cxx.

171  {
172  std::ostringstream defect;
173  defect << " " << defectBeginChannel;
174  if (defectBeginChannel!=defectEndChannel) {
175  defect << "-" << defectEndChannel;
176  }
177  defect << " ";
178  return defect.str();
179 }

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

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

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

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

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

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

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

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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

◆ finalize()

StatusCode SCTCalibWriteTool::finalize ( )
virtual

Definition at line 124 of file SCTCalibWriteTool.cxx.

124  {
125  ATH_MSG_DEBUG("SCTCalibWriteTool::finalize");
126  if (!m_streamer.release().isSuccess()) {
127  return StatusCode::FAILURE;
128  }
129  if (!m_IOVDbSvc.release().isSuccess()) {
130  return StatusCode::FAILURE;
131  }
132  ATH_MSG_DEBUG("Thank you for using the SCTCalibWriteTool");
133  return StatusCode::SUCCESS;
134 }

◆ getAttrListCollectionByFolder()

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

Definition at line 462 of file SCTCalibWriteTool.cxx.

462  {
463  std::lock_guard<std::mutex> lock{m_mutex};
464  // trying to find the pointer in the hashmap
465  // if it exists, return it, otherwise put it in.
466  const CondAttrListCollection* attrListCollection{nullptr};
467  if (m_attrListCollectionMap.count(foldername) == 0) {
468  if (detStore()->retrieve(attrListCollection, foldername).isFailure()) {
469  ATH_MSG_ERROR("Could not retrieve " << foldername);
470  return nullptr;
471  }
472  m_attrListCollectionMap.insert(make_pair(foldername, attrListCollection));
473  } else {
474  attrListCollection = m_attrListCollectionMap[foldername];
475  }
476  return attrListCollection;
477 }

◆ initialize()

StatusCode SCTCalibWriteTool::initialize ( )
virtual

Definition at line 82 of file SCTCalibWriteTool.cxx.

83 {
84 
85  ATH_MSG_DEBUG("in SCTCalibWriteTool::initialize start");
86 
87  if (detStore()->retrieve(m_pHelper,"SCT_ID").isFailure()) {
88  ATH_MSG_ERROR("SCT mgr failed to retrieve");
89  return StatusCode::FAILURE;
90  }
91 
92  // ------------------------------------------------------------
93  // The following is required for writing out something to COOL
94 
95  // CondAttrListCollection to store table temporarily
96  m_attrListColl = std::make_unique<CondAttrListCollection>(true);
97  m_attrListColl_deadStrip = std::make_unique<CondAttrListCollection>(true);
98  m_attrListColl_deadChip = std::make_unique<CondAttrListCollection>(true);
99  m_attrListColl_eff = std::make_unique<CondAttrListCollection>(true);
100  m_attrListColl_no = std::make_unique<CondAttrListCollection>(true);
101  m_attrListColl_RawOccu = std::make_unique<CondAttrListCollection>(true);
102  m_attrListColl_BSErr = std::make_unique<CondAttrListCollection>(true);
103  m_attrListColl_LA = std::make_unique<CondAttrListCollection>(true);
104 
105  // Get the IOVRegistrationSvc when needed
106  if (m_regIOV) {
107 
108  if (service("IOVRegistrationSvc", m_regSvc).isFailure()) {
109  ATH_MSG_ERROR("Unable to find IOVRegistrationSvc ");
110  return StatusCode::FAILURE;
111  }
112  }
113 
114  // Retrieve IOVDb service
115  if (m_IOVDbSvc.retrieve().isFailure())
116  return msg(MSG:: ERROR)<< "Failed to retrieve IOVDbSvc " << endmsg, StatusCode::FAILURE;
117 
118  return StatusCode::SUCCESS;
119 }

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

◆ interfaceID()

const InterfaceID & SCTCalibWriteTool::interfaceID ( )
inlinestatic

Definition at line 229 of file SCTCalibWriteTool.h.

229  {
230  static const InterfaceID IID{"SCTCalibWriteTool", 1, 0};
231  return IID;
232 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

◆ queryInterface()

StatusCode SCTCalibWriteTool::queryInterface ( const InterfaceID &  riid,
void **  ppvIF 
)
virtual

Definition at line 69 of file SCTCalibWriteTool.cxx.

70 {
71  if (SCTCalibWriteTool::interfaceID().versionMatch(riid) ) {
72  *ppvIF = static_cast<SCTCalibWriteTool*>(this);
73  } else {
74  return AthAlgTool::queryInterface(riid, ppvIF);
75  }
76  return StatusCode::SUCCESS;
77 }

◆ recordAndStream()

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

Definition at line 667 of file SCTCalibWriteTool.cxx.

667  {
668  ATH_MSG_DEBUG("recordAndStream start " << foldername);
669  if (m_writeCondObjs) {
670  if (detStore()->record(std::move(pCollection), foldername).isFailure()) {
671  ATH_MSG_ERROR("Could not record "<<foldername);
672  return StatusCode::FAILURE;
673  }
674  flag=true;
675  if (streamOutCondObjectsWithErrMsg(s_defectFolderName).isFailure()) return StatusCode::FAILURE;
676  }
677  return StatusCode::SUCCESS;
678 }

◆ registerCondObjects()

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

Definition at line 600 of file SCTCalibWriteTool.cxx.

600  {
601  // Register the IOV DB with the conditions data written out
602  ATH_MSG_DEBUG("registerCondObjects start");
603  if (m_readWriteCool) {
604  // Can only write out AttrList's if this is NOT write and reg in two steps
605  if (!m_twoStepWriteReg) {
606  // Using COOL, write out attrlist and collection of attrlists
607  // attrlist collection
608  StatusCode sc;
609  unsigned int beginRun;
610  unsigned int endRun;
611  if (!m_manualiov) {
612 
613  const EventContext& ctx = Gaudi::Hive::currentContext();
614  beginRun = ctx.eventID().run_number();
615  endRun = beginRun;
616 
617  } else {
618  beginRun = m_beginRun;
619  if ( m_endRun != -1 ) endRun = m_endRun;
620  else endRun = IOVTime::MAXRUN;
621  }
622 
623  unsigned int beginLB{IOVTime::MINEVENT};
624  unsigned int endLB{IOVTime::MAXEVENT};
625 
626  ATH_MSG_DEBUG("registerCondObjects: registerCondObjects middle");
627 
628  if (not tagname.empty()) {
629  ATH_MSG_DEBUG("registerCondObjects: registerCondObjects before registerIOV 1");
630  ATH_MSG_DEBUG("registerCondObjects: foldername, tagname, beginRun, endRun, beginLB, endLB: " << foldername << ", " << tagname << ", " << beginRun << ", " << endRun << ", " << beginLB << ", " << endLB);
631  sc = m_regSvc->registerIOV("CondAttrListCollection", foldername, tagname, beginRun, endRun, beginLB, endLB);
632  ATH_MSG_DEBUG("registerCondObjects after registerIOV 1");
633  } else {
634  ATH_MSG_DEBUG("registerCondObjects before registerIOV 2");
635  ATH_MSG_DEBUG("registerCondObjects: foldername, beginRun, endRun, beginLB, endLB: " << foldername << ", " << beginRun << ", " << endRun << ", " << beginLB << ", " << endLB);
636  sc = m_regSvc->registerIOV("CondAttrListCollection", foldername, "", beginRun, endRun, beginLB, endLB);
637  ATH_MSG_DEBUG("registerCondObjects after registerIOV 2");
638  }
639  if (sc.isFailure()) {
640  ATH_MSG_ERROR("registerCondObjects: Could not register in IOV DB for CondAttrListCollection");
641  return StatusCode::FAILURE;
642  }
643  }
644  }
645 
646  ATH_MSG_DEBUG("registerCondObjects end");
647 
648  return StatusCode::SUCCESS;
649 }

◆ registerCondObjectsWithErrMsg()

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

Definition at line 654 of file SCTCalibWriteTool.cxx.

654  {
655  if (m_regIOV) {
656  if (registerCondObjects(foldername,tagname).isFailure()) {
657  ATH_MSG_ERROR("registerCondObjectsWithErrMsg: Could not register " << foldername);
658  return StatusCode::FAILURE;
659  }
660  }
661  return StatusCode::SUCCESS;
662 }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ 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 697 of file SCTCalibWriteTool.cxx.

697  {
698  int eta{sctId->eta_module(wafer_id)};
699  int phi{sctId->phi_module(wafer_id)};
700  int barrel_ec{sctId->barrel_ec(wafer_id)};
701  int layer{sctId->layer_disk(wafer_id)};
702  //
703  const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
704  attrList["SampleSize"].setValue(static_cast<int>(samplesize));
705  attrList[becName].setValue(static_cast<int>(barrel_ec));
706  attrList["Layer"].setValue(static_cast<int>(layer));
707  attrList["Eta"].setValue(static_cast<int>(eta));
708  attrList["Phi"].setValue(static_cast<int>(phi));
709 
710  return;
711 }

◆ streamOutCondObjects()

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

Definition at line 561 of file SCTCalibWriteTool.cxx.

561  {
562  ATH_MSG_DEBUG("streamOutCondObjects start");
563  if (m_streamer->connectOutput(m_streamName).isFailure()) {
564  ATH_MSG_ERROR("Could not connect stream to output");
565  return( StatusCode::FAILURE);
566  }
567  IAthenaOutputStreamTool::TypeKeyPairs typeKeys{1};
568  if (m_readWriteCool) {
569  IAthenaOutputStreamTool::TypeKeyPair attrCollPair{"CondAttrListCollection", foldername};
570  typeKeys[0] = attrCollPair;
571  }
572 
573  if (m_streamer->streamObjects(typeKeys).isFailure()) {
574  ATH_MSG_ERROR("Could not stream out AttributeLists");
575  return StatusCode::FAILURE;
576  }
577 
578  if (m_streamer->commitOutput().isFailure()) {
579  ATH_MSG_ERROR("Could not commit output stream");
580  return StatusCode::FAILURE;
581  }
582  return StatusCode::SUCCESS;
583 }

◆ streamOutCondObjectsWithErrMsg()

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

Definition at line 588 of file SCTCalibWriteTool.cxx.

588  {
589  ATH_MSG_DEBUG("streamOutCondObjectsWithErrMsg: foldername " << foldername);
590  if (streamOutCondObjects(foldername).isFailure()) {
591  ATH_MSG_ERROR("Could not create conditions object " << foldername);
592  return StatusCode::FAILURE;
593  }
594  return StatusCode::SUCCESS;
595 }

◆ stringToInt()

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

Definition at line 482 of file SCTCalibWriteTool.cxx.

482  {
483  return atoi(s.c_str());
484 }

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

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ wrapUpBSErrors()

StatusCode SCTCalibWriteTool::wrapUpBSErrors ( )

Definition at line 543 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpDeadChips()

StatusCode SCTCalibWriteTool::wrapUpDeadChips ( )

Definition at line 507 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpDeadStrips()

StatusCode SCTCalibWriteTool::wrapUpDeadStrips ( )

Definition at line 498 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpEfficiency()

StatusCode SCTCalibWriteTool::wrapUpEfficiency ( )

Definition at line 516 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpLorentzAngle()

StatusCode SCTCalibWriteTool::wrapUpLorentzAngle ( )

Definition at line 552 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpNoiseOccupancy()

StatusCode SCTCalibWriteTool::wrapUpNoiseOccupancy ( )

Definition at line 525 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpNoisyChannel()

StatusCode SCTCalibWriteTool::wrapUpNoisyChannel ( )

Definition at line 489 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpRawOccupancy()

StatusCode SCTCalibWriteTool::wrapUpRawOccupancy ( )

Definition at line 534 of file SCTCalibWriteTool.cxx.

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

Member Data Documentation

◆ ATLAS_THREAD_SAFE

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

Definition at line 186 of file SCTCalibWriteTool.h.

◆ m_attrListColl

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl
private

Definition at line 187 of file SCTCalibWriteTool.h.

◆ m_attrListColl_BSErr

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_BSErr
private

Definition at line 193 of file SCTCalibWriteTool.h.

◆ m_attrListColl_deadChip

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_deadChip
private

Definition at line 189 of file SCTCalibWriteTool.h.

◆ m_attrListColl_deadStrip

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_deadStrip
private

Definition at line 188 of file SCTCalibWriteTool.h.

◆ m_attrListColl_eff

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_eff
private

Definition at line 190 of file SCTCalibWriteTool.h.

◆ m_attrListColl_LA

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_LA
private

Definition at line 194 of file SCTCalibWriteTool.h.

◆ m_attrListColl_no

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_no
private

Definition at line 191 of file SCTCalibWriteTool.h.

◆ m_attrListColl_RawOccu

std::unique_ptr<CondAttrListCollection> SCTCalibWriteTool::m_attrListColl_RawOccu
private

Definition at line 192 of file SCTCalibWriteTool.h.

◆ m_beginRun

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

Definition at line 201 of file SCTCalibWriteTool.h.

◆ m_BSErrRecorded

bool SCTCalibWriteTool::m_BSErrRecorded {false}
private

Definition at line 223 of file SCTCalibWriteTool.h.

◆ m_deadChipRecorded

bool SCTCalibWriteTool::m_deadChipRecorded {false}
private

Definition at line 219 of file SCTCalibWriteTool.h.

◆ m_deadStripRecorded

bool SCTCalibWriteTool::m_deadStripRecorded {false}
private

Definition at line 218 of file SCTCalibWriteTool.h.

◆ m_defectRecorded

bool SCTCalibWriteTool::m_defectRecorded {false}
private

Definition at line 217 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 220 of file SCTCalibWriteTool.h.

◆ m_endRun

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

Definition at line 202 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 215 of file SCTCalibWriteTool.h.

◆ m_LARecorded

bool SCTCalibWriteTool::m_LARecorded {false}
private

Definition at line 224 of file SCTCalibWriteTool.h.

◆ m_manualiov

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

Definition at line 199 of file SCTCalibWriteTool.h.

◆ m_mutex

std::mutex SCTCalibWriteTool::m_mutex {}
mutableprivate

Definition at line 185 of file SCTCalibWriteTool.h.

◆ m_noRecorded

bool SCTCalibWriteTool::m_noRecorded {false}
private

Definition at line 221 of file SCTCalibWriteTool.h.

◆ m_pHelper

const SCT_ID* SCTCalibWriteTool::m_pHelper {nullptr}
private

Definition at line 225 of file SCTCalibWriteTool.h.

◆ m_RawOccuRecorded

bool SCTCalibWriteTool::m_RawOccuRecorded {false}
private

Definition at line 222 of file SCTCalibWriteTool.h.

◆ m_readWriteCool

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

Definition at line 197 of file SCTCalibWriteTool.h.

◆ m_regIOV

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

Definition at line 196 of file SCTCalibWriteTool.h.

◆ m_regSvc

IIOVRegistrationSvc* SCTCalibWriteTool::m_regSvc {nullptr}
private

Definition at line 213 of file SCTCalibWriteTool.h.

◆ m_streamer

ToolHandle<IAthenaOutputStreamTool> SCTCalibWriteTool::m_streamer {nullptr}
private

Definition at line 214 of file SCTCalibWriteTool.h.

◆ m_streamName

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

Definition at line 203 of file SCTCalibWriteTool.h.

◆ m_tagID4BSErrors

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

Definition at line 210 of file SCTCalibWriteTool.h.

◆ m_tagID4DeadChips

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

Definition at line 206 of file SCTCalibWriteTool.h.

◆ m_tagID4DeadStrips

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

Definition at line 205 of file SCTCalibWriteTool.h.

◆ m_tagID4Efficiency

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

Definition at line 207 of file SCTCalibWriteTool.h.

◆ m_tagID4LorentzAngle

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

Definition at line 211 of file SCTCalibWriteTool.h.

◆ m_tagID4NoiseOccupancy

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

Definition at line 208 of file SCTCalibWriteTool.h.

◆ m_tagID4NoisyStrips

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

Definition at line 204 of file SCTCalibWriteTool.h.

◆ m_tagID4RawOccupancy

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

Definition at line 209 of file SCTCalibWriteTool.h.

◆ m_twoStepWriteReg

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

Definition at line 198 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 200 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 195 of file SCTCalibWriteTool.h.

◆ s_BSErrFolderName

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

Definition at line 181 of file SCTCalibWriteTool.h.

◆ s_deadChipFolderName

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

Definition at line 177 of file SCTCalibWriteTool.h.

◆ s_deadStripFolderName

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

Definition at line 176 of file SCTCalibWriteTool.h.

◆ s_defectFolderName

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

Definition at line 175 of file SCTCalibWriteTool.h.

◆ s_effFolderName

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

Definition at line 178 of file SCTCalibWriteTool.h.

◆ s_LAFolderName

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

Definition at line 182 of file SCTCalibWriteTool.h.

◆ s_noFolderName

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

Definition at line 179 of file SCTCalibWriteTool.h.

◆ s_RawOccuFolderName

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

Definition at line 180 of file SCTCalibWriteTool.h.

◆ s_separator

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

Definition at line 174 of file SCTCalibWriteTool.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
SCTCalibWriteTool::m_BSErrRecorded
bool m_BSErrRecorded
Definition: SCTCalibWriteTool.h:223
SCTCalibWriteTool::m_mutex
std::mutex m_mutex
Definition: SCTCalibWriteTool.h:185
SCTCalibWriteTool::m_effRecorded
bool m_effRecorded
Definition: SCTCalibWriteTool.h:220
SCTCalibWriteTool::s_LAFolderName
static const std::string s_LAFolderName
Definition: SCTCalibWriteTool.h:182
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
IAthenaOutputStreamTool::TypeKeyPairs
std::vector< TypeKeyPair > TypeKeyPairs
Definition: IAthenaOutputStreamTool.h:99
SCTCalibWriteTool::m_RawOccuRecorded
bool m_RawOccuRecorded
Definition: SCTCalibWriteTool.h:222
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
IOVTime::MAXRUN
static constexpr uint32_t MAXRUN
Definition: IOVTime.h:48
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SCTCalibWriteTool::m_IOVDbSvc
ServiceHandle< IIOVDbSvc > m_IOVDbSvc
Definition: SCTCalibWriteTool.h:215
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
SCTCalibWriteTool::m_attrListColl_RawOccu
std::unique_ptr< CondAttrListCollection > m_attrListColl_RawOccu
Definition: SCTCalibWriteTool.h:192
SCTCalibWriteTool
Algorithm to test writing conditions data and reading them back.
Definition: SCTCalibWriteTool.h:57
SCTCalibWriteTool::m_deadChipRecorded
bool m_deadChipRecorded
Definition: SCTCalibWriteTool.h:219
SCTCalibWriteTool::s_RawOccuFolderName
static const std::string s_RawOccuFolderName
Definition: SCTCalibWriteTool.h:180
SCTCalibWriteTool::m_tagID4Efficiency
StringProperty m_tagID4Efficiency
Definition: SCTCalibWriteTool.h:207
SCTCalibWriteTool::createDefectString
std::string createDefectString(const int defectBeginChannel, const int defectEndChannel) const
Definition: SCTCalibWriteTool.cxx:171
python.checkUPD1.foldername
foldername
Definition: checkUPD1.py:77
SCTCalibWriteTool::m_attrListColl_eff
std::unique_ptr< CondAttrListCollection > m_attrListColl_eff
Definition: SCTCalibWriteTool.h:190
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
SCTCalibWriteTool::m_beginRun
IntegerProperty m_beginRun
Definition: SCTCalibWriteTool.h:201
SCTCalibWriteTool::m_pHelper
const SCT_ID * m_pHelper
Definition: SCTCalibWriteTool.h:225
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SCTCalibWriteTool::m_attrListColl_no
std::unique_ptr< CondAttrListCollection > m_attrListColl_no
Definition: SCTCalibWriteTool.h:191
SCTCalibWriteTool::m_tagID4DeadStrips
StringProperty m_tagID4DeadStrips
Definition: SCTCalibWriteTool.h:205
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
IIOVRegistrationSvc::registerIOV
virtual StatusCode registerIOV(const std::string &typeName) const =0
Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag ...
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SCTCalibWriteTool::m_attrListColl
std::unique_ptr< CondAttrListCollection > m_attrListColl
Definition: SCTCalibWriteTool.h:187
SCTCalibWriteTool::s_noFolderName
static const std::string s_noFolderName
Definition: SCTCalibWriteTool.h:179
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
SCTCalibWriteTool::m_tagID4LorentzAngle
StringProperty m_tagID4LorentzAngle
Definition: SCTCalibWriteTool.h:211
SCTCalibWriteTool::m_tagID4NoisyStrips
StringProperty m_tagID4NoisyStrips
Definition: SCTCalibWriteTool.h:204
SCTCalibWriteTool::m_endRun
IntegerProperty m_endRun
Definition: SCTCalibWriteTool.h:202
SCTCalibWriteTool::m_streamer
ToolHandle< IAthenaOutputStreamTool > m_streamer
Definition: SCTCalibWriteTool.h:214
SCTCalibWriteTool::m_twoStepWriteReg
BooleanProperty m_twoStepWriteReg
Definition: SCTCalibWriteTool.h:198
SCTCalibWriteTool::m_tagID4DeadChips
StringProperty m_tagID4DeadChips
Definition: SCTCalibWriteTool.h:206
SCTCalibWriteTool::s_deadChipFolderName
static const std::string s_deadChipFolderName
Definition: SCTCalibWriteTool.h:177
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SCTCalibWriteTool::m_defectRecorded
bool m_defectRecorded
Definition: SCTCalibWriteTool.h:217
SCTCalibWriteTool::m_regIOV
BooleanProperty m_regIOV
Definition: SCTCalibWriteTool.h:196
SCTCalibWriteTool::s_effFolderName
static const std::string s_effFolderName
Definition: SCTCalibWriteTool.h:178
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
master.flag
bool flag
Definition: master.py:29
IAthenaOutputStreamTool::TypeKeyPair
std::pair< std::string, std::string > TypeKeyPair
Stream out objects.
Definition: IAthenaOutputStreamTool.h:98
test_pyathena.parent
parent
Definition: test_pyathena.py:15
SCTCalibWriteTool::m_attrListColl_deadStrip
std::unique_ptr< CondAttrListCollection > m_attrListColl_deadStrip
Definition: SCTCalibWriteTool.h:188
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SCTCalibWriteTool::streamOutCondObjectsWithErrMsg
StatusCode streamOutCondObjectsWithErrMsg(const std::string &foldername)
Definition: SCTCalibWriteTool.cxx:588
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
SCTCalibWriteTool::m_tagID4RawOccupancy
StringProperty m_tagID4RawOccupancy
Definition: SCTCalibWriteTool.h:209
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SCTCalibWriteTool::m_attrListColl_BSErr
std::unique_ptr< CondAttrListCollection > m_attrListColl_BSErr
Definition: SCTCalibWriteTool.h:193
IOVTime::MAXEVENT
static constexpr uint32_t MAXEVENT
Definition: IOVTime.h:51
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
python.selection.number
number
Definition: selection.py:20
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
SCTCalibWriteTool::m_LARecorded
bool m_LARecorded
Definition: SCTCalibWriteTool.h:224
IOVTime::MINEVENT
static constexpr uint32_t MINEVENT
Definition: IOVTime.h:50
dq_defect_bulk_create_defects.defect
defect
Definition: dq_defect_bulk_create_defects.py:35
SCTCalibWriteTool::interfaceID
static const InterfaceID & interfaceID()
Definition: SCTCalibWriteTool.h:229
SCTCalibWriteTool::s_BSErrFolderName
static const std::string s_BSErrFolderName
Definition: SCTCalibWriteTool.h:181
SCTCalibWriteTool::s_defectFolderName
static const std::string s_defectFolderName
Definition: SCTCalibWriteTool.h:175
a
TList * a
Definition: liststreamerinfos.cxx:10
SCTCalibWriteTool::recordAndStream
StatusCode recordAndStream(std::unique_ptr< CondAttrListCollection > pCollection, const std::string &foldername, bool &flag)
Definition: SCTCalibWriteTool.cxx:667
h
SCT_ID::strip
int strip(const Identifier &id) const
Definition: SCT_ID.h:764
SCTCalibWriteTool::m_writeCondObjs
BooleanProperty m_writeCondObjs
Definition: SCTCalibWriteTool.h:195
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SCTCalibWriteTool::registerCondObjects
StatusCode registerCondObjects(const std::string &foldername, const std::string &tagname) const
Definition: SCTCalibWriteTool.cxx:600
SCTCalibWriteTool::m_attrListColl_deadChip
std::unique_ptr< CondAttrListCollection > m_attrListColl_deadChip
Definition: SCTCalibWriteTool.h:189
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
SCTCalibWriteTool::m_regSvc
IIOVRegistrationSvc * m_regSvc
Definition: SCTCalibWriteTool.h:213
SCTCalibWriteTool::m_version
IntegerProperty m_version
Definition: SCTCalibWriteTool.h:200
SCTCalibWriteTool::m_tagID4NoiseOccupancy
StringProperty m_tagID4NoiseOccupancy
Definition: SCTCalibWriteTool.h:208
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
tagname
Definition: tagname.h:29
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
SCTCalibWriteTool::m_noRecorded
bool m_noRecorded
Definition: SCTCalibWriteTool.h:221
SCTCalibWriteTool::registerCondObjectsWithErrMsg
StatusCode registerCondObjectsWithErrMsg(const std::string &foldername, const std::string &tagname) const
Definition: SCTCalibWriteTool.cxx:654
SCTCalibWriteTool::m_streamName
StringProperty m_streamName
Definition: SCTCalibWriteTool.h:203
SCTCalibWriteTool::m_tagID4BSErrors
StringProperty m_tagID4BSErrors
Definition: SCTCalibWriteTool.h:210
SCTCalibWriteTool::m_readWriteCool
BooleanProperty m_readWriteCool
Definition: SCTCalibWriteTool.h:197
SCTCalibWriteTool::m_manualiov
BooleanProperty m_manualiov
Definition: SCTCalibWriteTool.h:199
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
SCTCalibWriteTool::streamOutCondObjects
StatusCode streamOutCondObjects(const std::string &foldername)
Definition: SCTCalibWriteTool.cxx:561
SCTCalibWriteTool::m_deadStripRecorded
bool m_deadStripRecorded
Definition: SCTCalibWriteTool.h:218
fitman.k
k
Definition: fitman.py:528
SCTCalibWriteTool::m_attrListColl_LA
std::unique_ptr< CondAttrListCollection > m_attrListColl_LA
Definition: SCTCalibWriteTool.h:194
SCTCalibWriteTool::s_deadStripFolderName
static const std::string s_deadStripFolderName
Definition: SCTCalibWriteTool.h:176
Generated on Fri Jun 28 2024 21:58:40 for ATLAS Offline Software by   doxygen 1.8.18