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", ""}
 
ServiceHandle< IIOVRegistrationSvc > m_regSvc
 
ToolHandle< IAthenaOutputStreamTool > m_streamer {nullptr}
 
ServiceHandle< IIOVDbSvc > m_IOVDbSvc
 
bool m_defectRecorded {false}
 
bool m_deadStripRecorded {false}
 
bool m_deadChipRecorded {false}
 
bool m_effRecorded {false}
 
bool m_noRecorded {false}
 
bool m_RawOccuRecorded {false}
 
bool m_BSErrRecorded {false}
 
bool m_LARecorded {false}
 
const SCT_ID * m_pHelper {nullptr}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static const std::string s_separator {"-"}
 
static const std::string s_defectFolderName {"/SCT/Derived/Monitoring"}
 
static const std::string s_deadStripFolderName {"/SCT/Derived/DeadStrips"}
 
static const std::string s_deadChipFolderName {"/SCT/Derived/DeadChips"}
 
static const std::string s_effFolderName {"/SCT/Derived/Efficiency"}
 
static const std::string s_noFolderName {"/SCT/Derived/NoiseOccupancy"}
 
static const std::string s_RawOccuFolderName {"/SCT/Derived/RawOccupancy"}
 
static const std::string s_BSErrFolderName {"/SCT/Derived/BSErrorsRun2"}
 
static const std::string s_LAFolderName {"/SCT/Derived/LorentzAngleRun2_v2"}
 

Detailed Description

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

50  :
51  AthAlgTool(type, name, parent),
52  m_regSvc("IOVRegistrationSvc", name),
53  m_streamer(((m_version == 0) ? "AthenaOutputStreamTool" : "AthenaPoolOutputStreamTool"), this),
54  m_IOVDbSvc("IOVDbSvc", name)
55 {
56 }

◆ ~SCTCalibWriteTool()

SCTCalibWriteTool::~SCTCalibWriteTool ( )
virtual

Definition at line 60 of file SCTCalibWriteTool.cxx.

61 {
62 }

Member Function Documentation

◆ addDefect()

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

Definition at line 142 of file SCTCalibWriteTool.cxx.

142  {
143  // check size of defect list,
144  // if it is empty then use createDefectString to make first entry.
145  if (defectlist.empty()) return createDefectString(defectBeginChannel, defectEndChannel);
146 
147  // adding another Defect in DefectList
148  std::ostringstream defect;
149  defect << defectlist << " " << defectBeginChannel;
150  if (defectBeginChannel==defectEndChannel) {
151  defect << " ";
152  } else {
153  defect << "-" << defectEndChannel << " ";
154  }
155  return defect.str();
156 }

◆ addNumber()

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

Definition at line 175 of file SCTCalibWriteTool.cxx.

175  {
176  std::ostringstream num_string;
177  // if it is empty then use createDefectString to make first entry.
178  if (numStr.empty()) {
179  num_string << number;
180  } else { // adding another number to numStr
181  num_string << numStr << " " << number;
182  }
183  return num_string.str();
184 }

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

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

◆ createBasicDbSpec()

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

Definition at line 673 of file SCTCalibWriteTool.cxx.

673  {
674  coral::AttributeListSpecification* attrSpec{new coral::AttributeListSpecification{}};
675  const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
676  attrSpec->extend("SampleSize", "int");
677  attrSpec->extend(becName, "int");
678  attrSpec->extend("Layer", "int");
679  attrSpec->extend("Eta", "int");
680  attrSpec->extend("Phi", "int");
681  return attrSpec;
682 }

◆ createDefectString()

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

Definition at line 161 of file SCTCalibWriteTool.cxx.

161  {
162  std::ostringstream defect;
163  defect << " " << defectBeginChannel;
164  if (defectBeginChannel!=defectEndChannel) {
165  defect << "-" << defectEndChannel;
166  }
167  defect << " ";
168  return defect.str();
169 }

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

114  {
115  ATH_MSG_DEBUG("SCTCalibWriteTool::finalize");
116  if (!m_streamer.release().isSuccess()) {
117  return StatusCode::FAILURE;
118  }
119  if (!m_IOVDbSvc.release().isSuccess()) {
120  return StatusCode::FAILURE;
121  }
122  ATH_MSG_DEBUG("Thank you for using the SCTCalibWriteTool");
123  return StatusCode::SUCCESS;
124 }

◆ getAttrListCollectionByFolder()

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

Definition at line 452 of file SCTCalibWriteTool.cxx.

452  {
453  std::lock_guard<std::mutex> lock{m_mutex};
454  // trying to find the pointer in the hashmap
455  // if it exists, return it, otherwise put it in.
456  const CondAttrListCollection* attrListCollection{nullptr};
457  if (m_attrListCollectionMap.count(foldername) == 0) {
458  if (detStore()->retrieve(attrListCollection, foldername).isFailure()) {
459  ATH_MSG_ERROR("Could not retrieve " << foldername);
460  return nullptr;
461  }
462  m_attrListCollectionMap.insert(make_pair(foldername, attrListCollection));
463  } else {
464  attrListCollection = m_attrListCollectionMap[foldername];
465  }
466  return attrListCollection;
467 }

◆ initialize()

StatusCode SCTCalibWriteTool::initialize ( )
virtual

Definition at line 80 of file SCTCalibWriteTool.cxx.

81 {
82 
83  ATH_MSG_DEBUG("in SCTCalibWriteTool::initialize start");
84 
85  ATH_CHECK( detStore()->retrieve(m_pHelper,"SCT_ID") );
86 
87  // ------------------------------------------------------------
88  // The following is required for writing out something to COOL
89 
90  // CondAttrListCollection to store table temporarily
91  m_attrListColl = std::make_unique<CondAttrListCollection>(true);
92  m_attrListColl_deadStrip = std::make_unique<CondAttrListCollection>(true);
93  m_attrListColl_deadChip = std::make_unique<CondAttrListCollection>(true);
94  m_attrListColl_eff = std::make_unique<CondAttrListCollection>(true);
95  m_attrListColl_no = std::make_unique<CondAttrListCollection>(true);
96  m_attrListColl_RawOccu = std::make_unique<CondAttrListCollection>(true);
97  m_attrListColl_BSErr = std::make_unique<CondAttrListCollection>(true);
98  m_attrListColl_LA = std::make_unique<CondAttrListCollection>(true);
99 
100  // Get the IOVRegistrationSvc when needed
101  if (m_regIOV) {
102  ATH_CHECK( m_regSvc.retrieve() );
103  }
104 
105  // Retrieve IOVDb service
106  ATH_CHECK( m_IOVDbSvc.retrieve() );
107 
108  return StatusCode::SUCCESS;
109 }

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

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

◆ recordAndStream()

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

Definition at line 657 of file SCTCalibWriteTool.cxx.

657  {
658  ATH_MSG_DEBUG("recordAndStream start " << foldername);
659  if (m_writeCondObjs) {
660  if (detStore()->record(std::move(pCollection), foldername).isFailure()) {
661  ATH_MSG_ERROR("Could not record "<<foldername);
662  return StatusCode::FAILURE;
663  }
664  flag=true;
665  if (streamOutCondObjectsWithErrMsg(s_defectFolderName).isFailure()) return StatusCode::FAILURE;
666  }
667  return StatusCode::SUCCESS;
668 }

◆ registerCondObjects()

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

Definition at line 590 of file SCTCalibWriteTool.cxx.

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

◆ registerCondObjectsWithErrMsg()

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

Definition at line 644 of file SCTCalibWriteTool.cxx.

644  {
645  if (m_regIOV) {
646  if (registerCondObjects(foldername,tagname).isFailure()) {
647  ATH_MSG_ERROR("registerCondObjectsWithErrMsg: Could not register " << foldername);
648  return StatusCode::FAILURE;
649  }
650  }
651  return StatusCode::SUCCESS;
652 }

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

687  {
688  int eta{sctId->eta_module(wafer_id)};
689  int phi{sctId->phi_module(wafer_id)};
690  int barrel_ec{sctId->barrel_ec(wafer_id)};
691  int layer{sctId->layer_disk(wafer_id)};
692  //
693  const std::string becName{capsFormat?"BarrelEndcap":"barrel_endcap"};
694  attrList["SampleSize"].setValue(static_cast<int>(samplesize));
695  attrList[becName].setValue(static_cast<int>(barrel_ec));
696  attrList["Layer"].setValue(static_cast<int>(layer));
697  attrList["Eta"].setValue(static_cast<int>(eta));
698  attrList["Phi"].setValue(static_cast<int>(phi));
699 
700  return;
701 }

◆ streamOutCondObjects()

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

Definition at line 551 of file SCTCalibWriteTool.cxx.

551  {
552  ATH_MSG_DEBUG("streamOutCondObjects start");
553  if (m_streamer->connectOutput(m_streamName).isFailure()) {
554  ATH_MSG_ERROR("Could not connect stream to output");
555  return( StatusCode::FAILURE);
556  }
557  IAthenaOutputStreamTool::TypeKeyPairs typeKeys{1};
558  if (m_readWriteCool) {
559  IAthenaOutputStreamTool::TypeKeyPair attrCollPair{"CondAttrListCollection", foldername};
560  typeKeys[0] = attrCollPair;
561  }
562 
563  if (m_streamer->streamObjects(typeKeys).isFailure()) {
564  ATH_MSG_ERROR("Could not stream out AttributeLists");
565  return StatusCode::FAILURE;
566  }
567 
568  if (m_streamer->commitOutput().isFailure()) {
569  ATH_MSG_ERROR("Could not commit output stream");
570  return StatusCode::FAILURE;
571  }
572  return StatusCode::SUCCESS;
573 }

◆ streamOutCondObjectsWithErrMsg()

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

Definition at line 578 of file SCTCalibWriteTool.cxx.

578  {
579  ATH_MSG_DEBUG("streamOutCondObjectsWithErrMsg: foldername " << foldername);
580  if (streamOutCondObjects(foldername).isFailure()) {
581  ATH_MSG_ERROR("Could not create conditions object " << foldername);
582  return StatusCode::FAILURE;
583  }
584  return StatusCode::SUCCESS;
585 }

◆ stringToInt()

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

Definition at line 472 of file SCTCalibWriteTool.cxx.

472  {
473  return atoi(s.c_str());
474 }

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

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

◆ wrapUpDeadChips()

StatusCode SCTCalibWriteTool::wrapUpDeadChips ( )

Definition at line 497 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpDeadStrips()

StatusCode SCTCalibWriteTool::wrapUpDeadStrips ( )

Definition at line 488 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpEfficiency()

StatusCode SCTCalibWriteTool::wrapUpEfficiency ( )

Definition at line 506 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpLorentzAngle()

StatusCode SCTCalibWriteTool::wrapUpLorentzAngle ( )

Definition at line 542 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpNoiseOccupancy()

StatusCode SCTCalibWriteTool::wrapUpNoiseOccupancy ( )

Definition at line 515 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpNoisyChannel()

StatusCode SCTCalibWriteTool::wrapUpNoisyChannel ( )

Definition at line 479 of file SCTCalibWriteTool.cxx.

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

◆ wrapUpRawOccupancy()

StatusCode SCTCalibWriteTool::wrapUpRawOccupancy ( )

Definition at line 524 of file SCTCalibWriteTool.cxx.

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

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

ServiceHandle<IIOVRegistrationSvc> SCTCalibWriteTool::m_regSvc
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:100
SCTCalibWriteTool::m_RawOccuRecorded
bool m_RawOccuRecorded
Definition: SCTCalibWriteTool.h:222
SCTCalibWriteTool::m_regSvc
ServiceHandle< IIOVRegistrationSvc > m_regSvc
Definition: SCTCalibWriteTool.h:213
IOVTime::MAXRUN
static constexpr uint32_t MAXRUN
Definition: IOVTime.h:48
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SCTCalibWriteTool::m_IOVDbSvc
ServiceHandle< IIOVDbSvc > m_IOVDbSvc
Definition: SCTCalibWriteTool.h:215
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
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:161
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
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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
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:99
test_pyathena.parent
parent
Definition: test_pyathena.py:15
SCTCalibWriteTool::m_attrListColl_deadStrip
std::unique_ptr< CondAttrListCollection > m_attrListColl_deadStrip
Definition: SCTCalibWriteTool.h:188
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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:578
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:221
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:657
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:590
SCTCalibWriteTool::m_attrListColl_deadChip
std::unique_ptr< CondAttrListCollection > m_attrListColl_deadChip
Definition: SCTCalibWriteTool.h:189
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:623
tagname
Definition: tagname.h:29
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:798
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:644
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:551
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 Thu Nov 7 2024 21:56:09 for ATLAS Offline Software by   doxygen 1.8.18