ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
IOVRegistrationSvc Class Reference

#include <IOVRegistrationSvc.h>

Inheritance diagram for IOVRegistrationSvc:
Collaboration diagram for IOVRegistrationSvc:

Public Member Functions

 IOVRegistrationSvc (const std::string &name, ISvcLocator *svc)
 
virtual ~IOVRegistrationSvc ()
 
virtual const InterfaceID & type () const
 Service type. More...
 
virtual StatusCode registerIOV (const std::string &typeName) const
 Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &tag) const
 Register IOV DB for an object given its typeName - run/LB numbers interval or times interval taken from JobOptions tag is specified Choice between run/LB and timestamp given in JobOptions. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &tag) const
 Register IOV DB for an object given its typeName and its key run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
 Register IOV DB for an object given its typeName, tag and run/LB numbers interval. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &tag, uint64_t beginTime, uint64_t endTime) const
 Register IOV DB for an object given its typeName, tag and times interval. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
 Register IOV DB for an object given its typeName, key, tag and run/LB numbers interval. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &tag, uint64_t beginTime, uint64_t endTime) const
 Register IOV DB for an object given its typeName, key, tag and times interval. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &folder, const std::string &tag, unsigned int beginRun, unsigned int endRun, unsigned int beginLB, unsigned int endLB) const
 Register IOV DB for an object given its typeName, key, folder, tag and run/LB numbers interval. More...
 
virtual StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &folder, const std::string &tag, uint64_t beginTime, uint64_t endTime) const
 Register IOV DB for an object given its typeName, key, folder, tag and times interval. More...
 
virtual StatusCode initialize ()
 Initialize AlgTool. More...
 
virtual StatusCode finalize ()
 Finalize AlgTool. More...
 

Private Member Functions

StatusCode registerIOV (const std::string &typeName, const std::string &key, const std::string &folder, const std::string &tag, const IOVTime &begin, const IOVTime &end) const
 
StatusCode registerIOVCOOL (const std::string &typeName, const std::string &key, const std::string &folderName, const std::string &tag, const IOVTime &begin, const IOVTime &end) const
 
cool::StorageType::TypeId coralToCoolType (const std::string &parname, const std::string &coralName) const
 
StatusCode getStringAddress (const CLID &clid, const std::string &key, std::string &saddr) const
 
uint64_t timeToNano (const unsigned long int timesec) const
 
virtual StatusCode buildDescription (const std::string &identifier, const std::string &value, std::string &description) const
 Build the folder description field add in front of the description the value with identifier-markups. More...
 
StatusCode splitAddress (const std::string &address, std::string &address_header, std::string &address_data) const
 Split address in its header and data parts. More...
 

Private Attributes

Gaudi::Property< bool > m_recreateFolders {this, "RecreateFolders", false}
 
Gaudi::Property< unsigned int > m_beginRun {this, "BeginRun", IOVTime::MINRUN}
 
Gaudi::Property< unsigned int > m_endRun {this, "EndRun", IOVTime::MAXRUN}
 
Gaudi::Property< unsigned int > m_beginLB {this, "BeginLB", IOVTime::MINEVENT}
 
Gaudi::Property< unsigned int > m_endLB {this, "EndLB", IOVTime::MAXEVENT}
 
Gaudi::Property< unsigned long > m_beginTime {this, "BeginTime", IOVTime::MINTIMESTAMP}
 
Gaudi::Property< unsigned long > m_endTime {this, "EndTime", IOVTime::MAXEVENT}
 
Gaudi::Property< std::string > m_tag {this, "IOVDbTag", ""}
 
Gaudi::Property< bool > m_timeStamp {this, "IOVDbTimeStamp", false}
 
Gaudi::Property< std::string > m_tagDescription {this, "TagDescription", "Athena IOVRegistrationSvc"}
 
Gaudi::Property< bool > m_writeKeyInfo {this, "writeKeyInfo", true}
 
Gaudi::Property< bool > m_userTags {this, "userTags", true}
 
Gaudi::Property< bool > m_userTagsUH {this, "userTagsUpdateHead", false}
 
Gaudi::Property< bool > m_svFolder {this, "SVFolder", false}
 
Gaudi::Property< bool > m_payloadTable {this, "PayloadTable", false}
 
Gaudi::Property< bool > m_forceGlobalIOV {this, "UseGlobalIOVForCollections", false}
 
Gaudi::Property< std::vector< std::string > > m_overrideName {this, "OverrideNames", {}}
 
Gaudi::Property< std::vector< std::string > > m_overrideType {this, "OverrideTypes", {}}
 
ServiceHandle< IIOVCondDbSvc > m_iov_db
 
ServiceHandle< StoreGateSvc > m_detStore
 
ServiceHandle< IAddressCreator > m_persSvc
 
ServiceHandle< IClassIDSvc > m_clidSvc
 

Friends

class SvcFactory< IOVRegistrationSvc >
 

Detailed Description

Properties:

Definition at line 53 of file IOVRegistrationSvc.h.

Constructor & Destructor Documentation

◆ IOVRegistrationSvc()

IOVRegistrationSvc::IOVRegistrationSvc ( const std::string &  name,
ISvcLocator *  svc 
)

Definition at line 48 of file IOVRegistrationSvc.cxx.

49  :
50  base_class( name, svc ),
51  m_iov_db ( "IOVDbSvc", name ),
52  m_detStore( "DetectorStore", name ),
53  m_persSvc ( "EventPersistencySvc", name ),
54  m_clidSvc ( "ClassIDSvc", name )
55 {
56 
57 }

◆ ~IOVRegistrationSvc()

IOVRegistrationSvc::~IOVRegistrationSvc ( )
virtual

Definition at line 60 of file IOVRegistrationSvc.cxx.

61 {}

Member Function Documentation

◆ buildDescription()

StatusCode IOVRegistrationSvc::buildDescription ( const std::string &  identifier,
const std::string &  value,
std::string &  description 
) const
privatevirtual

Build the folder description field add in front of the description the value with identifier-markups.

Definition at line 1129 of file IOVRegistrationSvc.cxx.

1131  {
1132  // this routine was originally in IOVDbSvc, moved here as only client
1133  // buids an XML fragment of form <identifier>value</identifier>
1134  if (identifier.empty() || value.empty()) {
1135  ATH_MSG_ERROR ("Identifier or value is null.");
1136  return StatusCode::FAILURE;
1137  }
1138  description = "<"+identifier+">"+value+"</"+identifier+">"+description;
1139  return StatusCode::SUCCESS;
1140 }

◆ coralToCoolType()

cool::StorageType::TypeId IOVRegistrationSvc::coralToCoolType ( const std::string &  parname,
const std::string &  coralName 
) const
private

Definition at line 1077 of file IOVRegistrationSvc.cxx.

1078  {
1079  // map coral type onto corresponding COOL storage type
1080  std::string coralType=coralName;
1081  // check for any overrides
1082  for (unsigned int i=0;i<m_overrideType.size();++i) {
1083  if (m_overrideName[i]==parname) {
1084  coralType=m_overrideType[i];
1085  ATH_MSG_INFO ("Override default type for attribute " <<
1086  parname << " - use " << coralType);
1087  }
1088  }
1089  // FIXME to include all CORAL/COOL types
1090  // give both the names of CORAL types, and COOL types which may get specified
1091  // as overrides
1092  if (coralType=="bool") return cool::StorageType::Bool;
1093  if (coralType=="UChar" || coralType=="unsigned char") return cool::StorageType::UChar;
1094  if (coralType=="Int16") return cool::StorageType::Int16;
1095  if (coralType=="UInt16") return cool::StorageType::UInt16;
1096  if (coralType=="Int32" || coralType=="int") return cool::StorageType::Int32;
1097  if (coralType=="UInt32" || coralType=="unsigned int") return cool::StorageType::UInt32;
1098  if (coralType=="UInt63" || coralType=="unsigned long long") return cool::StorageType::UInt63;
1099  if (coralType=="Int64" || coralType=="long long") return cool::StorageType::Int64;
1100  if (coralType=="Float" || coralType=="float") return cool::StorageType::Float;
1101  if (coralType=="Double" || coralType=="double") return cool::StorageType::Double;
1102  if (coralType=="String255") return cool::StorageType::String255;
1103  if (coralType=="String4k" || coralType=="string") return cool::StorageType::String4k;
1104  if (coralType=="String64k") return cool::StorageType::String64k;
1105  if (coralType=="String16M") return cool::StorageType::String16M;
1106  if (coralType=="blob" || coralType=="Blob64k")
1107  return cool::StorageType::Blob64k;
1108  if (coralType=="Blob16M") return cool::StorageType::Blob16M;
1109 
1110  // if we get here, mapping is undefined
1111  ATH_MSG_FATAL ("No COOL mapping defined for CORAL type " << coralName);
1112  throw std::exception();
1113 }

◆ finalize()

StatusCode IOVRegistrationSvc::finalize ( )
virtual

Finalize AlgTool.

Definition at line 144 of file IOVRegistrationSvc.cxx.

145 {
146  return StatusCode::SUCCESS;
147 }

◆ getStringAddress()

StatusCode IOVRegistrationSvc::getStringAddress ( const CLID &  clid,
const std::string &  key,
std::string &  saddr 
) const
private

◆ initialize()

StatusCode IOVRegistrationSvc::initialize ( )
virtual

Initialize AlgTool.

Definition at line 71 of file IOVRegistrationSvc.cxx.

72 {
73  ATH_MSG_DEBUG ("in initialize()");
74 
75  StatusCode sc = AthService::initialize();
76  if ( sc.isFailure() ) {
77  ATH_MSG_ERROR ("Unable to call base initialize method");
78  return StatusCode::FAILURE;
79  }
80 
81  // locate the conditions store ptr to it.
82  sc = m_detStore.retrieve();
83  if (!sc.isSuccess() || 0 == m_detStore) {
84  ATH_MSG_ERROR ("Could not find ConditionStore");
85  return StatusCode::FAILURE;
86  }
87 
88  // Get the IOVDbSvc
89  sc = m_iov_db.retrieve();
90  if ( sc.isFailure() ) {
91  ATH_MSG_ERROR ("Unable to get the IOVDbSvc");
92  return StatusCode::FAILURE;
93  }
94 
95  // Get the persistency mgr for conversion of IOpaqueAddress to
96  // string
97  sc = m_persSvc.retrieve();
98  if ( sc != StatusCode::SUCCESS ) {
99  ATH_MSG_ERROR (" Cannot get IAddressCreator interface of the EventPersistencySvc ");
100  return sc ;
101  }
102  ATH_MSG_DEBUG ("Found PersistencySvc ");
103 
104 
105  // Get the ClassIDSvc - to get typename for clid
106  sc = m_clidSvc.retrieve();
107  if (sc != StatusCode::SUCCESS ) {
108  ATH_MSG_ERROR (" Cannot get IClassIDSvc interface of the CLIDSvc " );
109  return sc ;
110  }
111  ATH_MSG_DEBUG ("Found CLIDSvc ");
112 
113 
114  ATH_MSG_DEBUG ("Properties ");
115  ATH_MSG_DEBUG ("RecreateFolders " << m_recreateFolders);
116  if (m_timeStamp)
117  {
118  ATH_MSG_DEBUG ("BeginTime " << m_beginTime);
119  ATH_MSG_DEBUG ("EndTime " << m_endTime);
120  }
121  else
122  {
123  ATH_MSG_DEBUG ("BeginRun " << m_beginRun);
124  ATH_MSG_DEBUG ("EndRun " << m_endRun);
125  ATH_MSG_DEBUG ("BeginLB " << m_beginLB);
126  ATH_MSG_DEBUG ("EndLB " << m_endLB);
127  }
128  ATH_MSG_DEBUG ("IOVDbTag " << m_tag);
129 
130  // check consistency of override specification, if any
131  if (m_overrideName.size()!=m_overrideType.size()) {
132  ATH_MSG_FATAL ("Inconsistent settings of OverrideNames and OverrideTypes parameters");
133  return StatusCode::FAILURE;
134  }
135  for (unsigned int i=0;i<m_overrideName.size();++i)
136  ATH_MSG_INFO ("Attributes with name " << m_overrideName[i] <<
137  " will be stored as COOL type " << m_overrideType[i]);
138  return StatusCode::SUCCESS;
139 
140 }

◆ registerIOV() [1/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName) const
virtual

Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.

Definition at line 151 of file IOVRegistrationSvc.cxx.

152 {
153  std::string key = "";
154 
155  if (m_timeStamp)
156  {
157  IOVTime start;
158  start.setTimestamp(timeToNano(m_beginTime));
159  IOVTime stop ;
160  stop.setTimestamp(timeToNano(m_endTime));
161 
162  return ( registerIOV( typeName,
163  key,key,
164  m_tag.value(),
165  start,
166  stop) );
167  }
168  else
169  {
170  IOVTime start;
171  start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
172  IOVTime stop;
173  stop.setRunEvent ( (unsigned long)m_endRun, (unsigned long)m_endLB );
174 
175  return ( registerIOV( typeName,
176  key,key,
177  m_tag.value(),
178  start,
179  stop) );
180  }
181 }

◆ registerIOV() [2/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  folder,
const std::string &  tag,
const IOVTime &  begin,
const IOVTime &  end 
) const
private

Definition at line 387 of file IOVRegistrationSvc.cxx.

393 {
394  // Register the conditions objects in the IOV database with
395  // start/stop as the time interval
396 
397 
398  msg() << MSG::DEBUG <<" in registerIOV()"
399  << " typename: " << typeName << " - tag: " << tag;
400  if (spec_key.empty())
401  {
402  msg() << " key: *empty* " << endmsg;
403  }
404  else
405  {
406  msg() << " spec_key " << spec_key << endmsg;
407  }
408  msg() << " - begin time: " << start
409  << " - end time: " << stop
410  << endmsg;
411 
412  // Check validity of start/stop
413  if(start.isBoth() || stop.isBoth() ||
414  start.isTimestamp() != stop.isTimestamp() ||
415  start.isRunEvent() != stop.isRunEvent()) {
416  ATH_MSG_ERROR ("Incorrect start/stop: "
417  << " isBoth: " << start.isBoth() << ":" << stop.isBoth()
418  << " isTimestamp: " << start.isTimestamp() << ":" << stop.isTimestamp()
419  << " isRunEvent: " << start.isRunEvent() << ":" << stop.isRunEvent());
420  return( StatusCode::FAILURE);
421  }
422 
423  return registerIOVCOOL( typeName,
424  spec_key,
425  folder,
426  tag,
427  start,
428  stop );
429 }

◆ registerIOV() [3/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  folder,
const std::string &  tag,
uint64_t  beginTime,
uint64_t  endTime 
) const
virtual

Register IOV DB for an object given its typeName, key, folder, tag and times interval.

Definition at line 361 of file IOVRegistrationSvc.cxx.

367 {
368  IOVTime start;
369  start.setTimestamp( beginTime );
370  IOVTime stop;
371  stop.setTimestamp ( endTime );
372 
373  return ( registerIOV( typeName,
374  key,
375  folder,
376  tag,
377  start,
378  stop) );
379 }

◆ registerIOV() [4/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  folder,
const std::string &  tag,
unsigned int  beginRun,
unsigned int  endRun,
unsigned int  beginLB,
unsigned int  endLB 
) const
virtual

Register IOV DB for an object given its typeName, key, folder, tag and run/LB numbers interval.

Definition at line 337 of file IOVRegistrationSvc.cxx.

345 {
346  IOVTime start;
347  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
348  IOVTime stop;
349  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
350 
351  return ( registerIOV( typeName,
352  key,
353  folder,
354  tag,
355  start,
356  stop) );
357 }

◆ registerIOV() [5/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  tag 
) const
virtual

Register IOV DB for an object given its typeName and its key run/LB numbers interval or times interval and tag are taken from JobOptions Choice between run/LB and timestamp given in JobOptions.

Definition at line 219 of file IOVRegistrationSvc.cxx.

221 {
222  if (m_timeStamp)
223  {
224  IOVTime start;
225  start.setTimestamp( timeToNano(m_beginTime) );
226  IOVTime stop ;
227  stop.setTimestamp ( timeToNano(m_endTime) );
228 
229  return ( registerIOV( typeName,
230  key,key,
231  tag,
232  start,
233  stop) );
234  }
235  else
236  {
237  IOVTime start;
238  start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
239  IOVTime stop;
240  stop.setRunEvent ( (unsigned long)m_endRun, (unsigned long)m_endLB );
241 
242  return ( registerIOV( typeName,
243  key,key,
244  tag,
245  start,
246  stop) );
247  }
248 }

◆ registerIOV() [6/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  tag,
uint64_t  beginTime,
uint64_t  endTime 
) const
virtual

Register IOV DB for an object given its typeName, key, tag and times interval.

Definition at line 317 of file IOVRegistrationSvc.cxx.

322 {
323  IOVTime start;
324  start.setTimestamp( beginTime );
325  IOVTime stop;
326  stop.setTimestamp ( endTime );
327 
328  return ( registerIOV( typeName,
329  key,key,
330  tag,
331  start,
332  stop) );
333 }

◆ registerIOV() [7/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  key,
const std::string &  tag,
unsigned int  beginRun,
unsigned int  endRun,
unsigned int  beginLB,
unsigned int  endLB 
) const
virtual

Register IOV DB for an object given its typeName, key, tag and run/LB numbers interval.

Definition at line 295 of file IOVRegistrationSvc.cxx.

302 {
303  IOVTime start;
304  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
305  IOVTime stop;
306  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
307 
308  return ( registerIOV( typeName,
309  key,key,
310  tag,
311  start,
312  stop) );
313 }

◆ registerIOV() [8/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  tag 
) const
virtual

Register IOV DB for an object given its typeName - run/LB numbers interval or times interval taken from JobOptions tag is specified Choice between run/LB and timestamp given in JobOptions.

Definition at line 185 of file IOVRegistrationSvc.cxx.

186 {
187  std::string key = "";
188 
189  if (m_timeStamp)
190  {
191  IOVTime start;
192  start.setTimestamp( timeToNano(m_beginTime) );
193  IOVTime stop ;
194  stop.setTimestamp ( timeToNano(m_endTime) );
195 
196  return ( registerIOV( typeName,
197  key,key,
198  tag,
199  start,
200  stop) );
201  }
202  else
203  {
204  IOVTime start;
205  start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
206  IOVTime stop;
207  stop.setRunEvent ( (unsigned long)m_endRun, (unsigned long)m_endLB );
208 
209  return ( registerIOV( typeName,
210  key,key,
211  tag,
212  start,
213  stop) );
214  }
215 }

◆ registerIOV() [9/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  tag,
uint64_t  beginTime,
uint64_t  endTime 
) const
virtual

Register IOV DB for an object given its typeName, tag and times interval.

Definition at line 274 of file IOVRegistrationSvc.cxx.

278 {
279  IOVTime start;
280  start.setTimestamp( beginTime );
281  IOVTime stop;
282  stop.setTimestamp ( endTime );
283 
284  std::string key = "";
285 
286  return ( registerIOV( typeName,
287  key,key,
288  tag,
289  start,
290  stop) );
291 }

◆ registerIOV() [10/10]

StatusCode IOVRegistrationSvc::registerIOV ( const std::string &  typeName,
const std::string &  tag,
unsigned int  beginRun,
unsigned int  endRun,
unsigned int  beginLB,
unsigned int  endLB 
) const
virtual

Register IOV DB for an object given its typeName, tag and run/LB numbers interval.

Definition at line 252 of file IOVRegistrationSvc.cxx.

258 {
259  IOVTime start;
260  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
261  IOVTime stop;
262  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
263  std::string key = "";
264 
265  return ( registerIOV( typeName,
266  key,key,
267  tag,
268  start,
269  stop) );
270 }

◆ registerIOVCOOL()

StatusCode IOVRegistrationSvc::registerIOVCOOL ( const std::string &  typeName,
const std::string &  key,
const std::string &  folderName,
const std::string &  tag,
const IOVTime &  begin,
const IOVTime &  end 
) const
private

Definition at line 435 of file IOVRegistrationSvc.cxx.

441 {
442  // Register the conditions objects in the IOV database with
443  // start/stop as the time interval
444 
445 
446  ATH_MSG_DEBUG (" in registerIOVCOOL()" );
447 
448 
449  // Find the clid for type name from the CLIDSvc
450  CLID clid;
451  StatusCode sc = m_clidSvc->getIDOfTypeName(typeName, clid);
452  if (sc.isFailure()) {
453  ATH_MSG_ERROR ("Could not get clid for typeName " << typeName);
454  return( StatusCode::FAILURE);
455  }
456 
457  try {
458 
459  // There are two possible states:
460  // 1) The DataObject is stored elsewhere and we store in the
461  // IOVDb only a stringified ref to the object, or
462  // 2) The DataObject is an AthenaAttributeList or a
463  // CondAttrListCollection and then we store it directly into
464  // the IOVDb.
465  //
466  // The second case is detected either with the type name,
467  // for AthenaAttributeList or CondAttrListCollection, or by
468  // checking the real type of the IOA - i.e. if it is a
469  // CondAttrListCollAddress then a CondAttrListCollection may
470  // have been filled with pool refs stored in it.
471 
472  bool storeRef = true;
473  bool storeAttrListColl = false;
474  bool needSGaddr=false;
475  if ("AthenaAttributeList" == typeName) {
476  storeRef = false;
477  needSGaddr=false;
478  }
479  if ("CondAttrListCollection" == typeName) {
480  storeRef = false;
481  storeAttrListColl = true;
482  needSGaddr=false;
483  }
484  // (See after retrieval of the IOA for a final check of the
485  // type of storage.)
486 
487  // Get IOpaqueAddress, key and symlinks for each data object
488  // from StoreGate
489  IOpaqueAddress* addr=0;
490  std::string key = spec_key;
491  std::vector<CLID> symlinks;
492  SG::DataProxy* proxy;
493  if (key.empty()) {
494  // Get IOpaqueAddress and key for each data object from
495  // StoreGate
496  proxy = m_detStore->proxy(clid);
497  if (!proxy) {
498  ATH_MSG_ERROR ("Could not get proxy for clid " << clid);
499  return( StatusCode::FAILURE);
500  }
501 
502  // Get key to be used for folder name
503  key = proxy->name();
504  // get proxy address - this will fail if object not streamed out
505  // but this can be recovered later for inline data
506  addr = proxy->address();
507  } else {
508  // Get IOpaqueAddress for each data object from StoreGate
509  proxy = m_detStore->proxy(clid, key);
510  if (!proxy) {
511  ATH_MSG_ERROR ("Could not get proxy for clid " << clid << " and key " << key);
512  return( StatusCode::FAILURE );
513  }
514  // get proxy address - this will fail if object not streamed out
515  // but this can be recovered later for inline data
516  addr = proxy->address();
517  }
518  std::string saddr;
519  if (addr) {
520  // Get symlinks, if any
521  symlinks = proxy->transientID();
522  auto it = std::find (symlinks.begin(), symlinks.end(), clid);
523  if (it != symlinks.end()) {
524  symlinks.erase (it);
525  }
526 
527  // Check whether the IOA is a CondAttrListCollAddress - if so
528  // we will store a CondAttrListCollection
529  CondAttrListCollAddress* collAddr = dynamic_cast<CondAttrListCollAddress*>(addr);
530  if (collAddr) {
531  storeRef = false;
532  storeAttrListColl = true;
533  }
534  // Convert IOpaqueAddress to string via the persistency
535  // service. We then store the string address in the IOV DB
536  sc = m_persSvc->convertAddress(addr, saddr);
537  if (sc.isFailure()) {
538  ATH_MSG_WARNING ("Could not get string from IOpaqueAddress for clid " << clid
539  << " is BAD_STORAGE_TYPE: " << (sc == IConversionSvc::Status::BAD_STORAGE_TYPE));
540  return( StatusCode::FAILURE);
541  }
542  ATH_MSG_DEBUG ("String address = \"" << saddr << "\"");
543  } else {
544  // if no addr was found, object has not been streamed out
545  // this is OK providing we do not need the addr later
546  // i.e. plain CondAttrListCollection or AthenaAttributeList
547  if (needSGaddr) {
548  ATH_MSG_ERROR ("Could not get address for clid " << clid);
549  return( StatusCode::FAILURE );
550  } else {
551  ATH_MSG_DEBUG ("Faking address for " << typeName);
552  // fake the saddr contents
553  if ("AthenaAttributeList" == typeName) {
554  saddr="<address_header service_type=\"256\" clid=\"40774348\" /> POOLContainer_AthenaAttributeList][CLID=x";
555  } else if ("CondAttrListCollection" == typeName) {
556  saddr="<address_header service_type=\"256\" clid=\"1238547719\" /> POOLContainer_CondAttrListCollection][CLID=x";
557  } else {
558  ATH_MSG_ERROR ("Cannot fake stringaddress for typename "
559  << typeName);
560  }
561  }
562  }
563 
564  ATH_MSG_DEBUG ("Storing ref: " << storeRef
565  << " Storing AttrListCollection: " << storeAttrListColl);
566 
567  // Set folder name - in the present case this is defined
568  // to be the key
569  // RJH - unless a non-null folder is given on input
570  std::string local_folder;
571  if (""==folderName) {
572  local_folder = key;
573  } else {
574  local_folder=folderName;
575  }
576  ATH_MSG_DEBUG ("Using folder name " << local_folder);
577 
578  // Get COOL database in update mode (false == readOnly flag)
579  cool::IDatabasePtr db = m_iov_db->getDatabase(false);
580  if (!db) {
581  ATH_MSG_ERROR ("Could not get pointer to COOL db ");
582  return(StatusCode::FAILURE);
583  }
584  // get some information about the database connection for later checks
585  const cool::DatabaseId& dbid=db->databaseId();
586  // look for direct connection to production accounts
587  bool dbidprod=(dbid.find("oracle")!=std::string::npos && (
588  dbid.find("ATLAS_COOLONL_")!=std::string::npos ||
589  dbid.find("ATLAS_COOLOFL_")!=std::string::npos ||
590  dbid.find("ATLAS_COOL_")!=std::string::npos));
591  // look for use of writer account ('_W' in connection string)
592  bool dbidwriter=(dbid.find("oracle")!=std::string::npos &&
593  dbid.find("_W")!=std::string::npos);
594  ATH_MSG_DEBUG ("Identified prod/writer " << dbidprod << dbidwriter);
595  // do not allow write accesss to production servers
596  if (dbidprod) {
597  ATH_MSG_FATAL ("Direct update of production Oracle servers from Athena is FORBIDDEN");
598  ATH_MSG_FATAL ("Please write to SQLite file and then merge with AtlCoolMerge.py");
599  return StatusCode::FAILURE;
600  }
601 
602  // For AthenaAttributeList/CondAttrListCollection, save a pointer to the object
603  const AthenaAttributeList* attrList = 0;
604  const CondAttrListCollection* attrListColl = 0;
605 
606  if (!storeRef) {
607  if ("CondAttrListCollection"==typeName) {
608  if (StatusCode::SUCCESS!=m_detStore->
609  retrieve(attrListColl,key)) {
610  ATH_MSG_ERROR ("Could not find CondAttrListCollecton for "
611  << key);
612  return StatusCode::FAILURE;
613  }
614  } else if (storeAttrListColl) {
615  // have to go through SG proxy, as it is a collection of POOLref
616  if (addr) {
617  CondAttrListCollAddress* attrAddr = dynamic_cast<CondAttrListCollAddress*>(addr);
618  if (attrAddr) {
619  // Successful cast
620  attrListColl = attrAddr->attrListColl();
621  ATH_MSG_DEBUG ("Set attr list coll ptr ");
622  ATH_MSG_DEBUG ("addr, attrAddr, coll "
623  << addr << " " << attrAddr << " " << attrListColl);
624  } else {
625  ATH_MSG_ERROR ("Could not extract ptr for CondAttrListCollAddress ");
626  return StatusCode::FAILURE;
627  }
628  } else {
629  ATH_MSG_ERROR ("Cannot write out collection of POOLref without streaming them first" );
630  return StatusCode::FAILURE;
631  }
632  } else {
633  // Just AttrList - get directly from Storegate
634  if (StatusCode::SUCCESS!=m_detStore->retrieve(attrList,key)) {
635  ATH_MSG_ERROR ("Could not find AthenaAttributeList for "
636  << key);
637  return StatusCode::FAILURE;
638  }
639  }
640 
641  }
642 
643 
644  ATH_MSG_DEBUG ("Set attr list coll ptr " << attrListColl);
645 
646  // Save folder pointer
647  cool::IFolderPtr folder;
648 
649  // Create folders if required - a job option allows on to
650  // delete existing folders and then recreate them
651 
652  bool createFolders = false;
653 
654  if(db->existsFolder(local_folder)) {
655 
656  if (m_recreateFolders) {
657  // do not allow this action on production schema or with writer
658  if (dbidprod || dbidwriter) {
659  ATH_MSG_FATAL ("Apparent attempt to delete folder on production COOL schema " << dbid);
660  return StatusCode::FAILURE;
661  }
662 
663  ATH_MSG_DEBUG (" Deleting existing COOL Folder " << local_folder);
664  db->dropNode( local_folder );
665  createFolders = true;
666  }
667  else {
668  // Get folder
669  ATH_MSG_DEBUG ("COOL Folder " << local_folder << " exists");
670  folder = db->getFolder(local_folder);
671  }
672 
673  }
674  else {
675  ATH_MSG_DEBUG ("COOL Folder " << local_folder
676  << " does not exist - must create it");
677  createFolders = true;
678  }
679 
680  // Split the string address into header and data parts
681  std::string address_header;
682  std::string address_data;
683 
684  sc = splitAddress(saddr,address_header,address_data);
685  if (sc.isFailure()) {
686  ATH_MSG_ERROR ("Could not split address: "
687  << "addr: " << saddr << "\n"
688  << "hdr: " << address_header << "\n"
689  << "data " << address_data);
690  return( StatusCode::FAILURE);
691  }
692  msg() << MSG::DEBUG <<"split address: " << saddr << endmsg
693  << " hdr: " << address_header << endmsg
694  << " data: " << address_data << endmsg;
695 
696 
697  if(createFolders) {
698  // first make sure not using writer account -if so abort
699  if (dbidwriter) {
700  ATH_MSG_FATAL ("Apparent attempt to create folder using writer account, dbID is: " << dbid);
701  return StatusCode::FAILURE;
702  }
703 
704  // We store extra information in the folder description.
705  // This info is:
706  // typeName - required information
707  // symlinks - the extra StoreGate keys, if any
708  // key - optional, only needed if key != folder name
709  // timeStamp - either run-lumi (default) or time
710  // address_header - added by convention
711  //
712  //
713  // The convention is that the address_header is stored
714  // in the description, and the IOV interval data
715  // payload is just the pool reference in string form.
716  // The address_header and address_data can be obtained
717  // from the string address returned from the
718  // persistency service, using splitAddress
719 
720  std::string mergedNames;
721 
722  sc = buildDescription( "typeName", typeName,
723  mergedNames );
724  if (sc.isFailure()) {
725  ATH_MSG_ERROR ("Could not merge towards merged description: "
726  << "typeName: " << typeName);
727  return( StatusCode::FAILURE);
728  }
729 
730  sc = buildDescription( "addrHeader", address_header,
731  mergedNames );
732  if (sc.isFailure()) {
733  ATH_MSG_ERROR ("Could not merge towards merged description: "
734  << "addrHeader: " << address_header);
735  return( StatusCode::FAILURE);
736  }
737  // RJH - if key is not same as folder, and we want the read-back
738  // objects to end up in the TDS with the given Storegate key rather
739  // than the folder name, need to set the <key> attribute
740  // a jobOption WriteKeyInfo=FALSE disables this, in case you have
741  // created objects with the 'wrong' SG key and want the key
742  // on read-back to correspond to the folder name
743  if (local_folder!=key && m_writeKeyInfo) {
744  sc=buildDescription("key",key,mergedNames);
745  if (sc.isFailure()) {
746  ATH_MSG_ERROR ("Could not merge towards merged description: "
747  << "key: " << key);
748  return( StatusCode::FAILURE);
749  }
750  }
751 
752  // Add in symlink types
753  if (!symlinks.empty()) {
754  std::string symlinkTypes;
755  for (unsigned int i = 0; i < symlinks.size(); ++i) {
756  std::string type;
757  sc = m_clidSvc->getTypeNameOfID(symlinks[i], type);
758  if (sc.isFailure()) {
759  ATH_MSG_ERROR ("Could not get type name for symlink clid "
760  << symlinks[i]);
761  return( StatusCode::FAILURE);
762  }
763  else {
764  ATH_MSG_DEBUG ("adding symlink: clid, type "
765  << symlinks[i] << " " << type);
766  }
767  if (symlinkTypes.size()) symlinkTypes += ':';
768  symlinkTypes += type;
769  }
770  sc=buildDescription("symlinks", symlinkTypes, mergedNames);
771  if (sc.isFailure()) {
772  msg() << MSG::ERROR <<"Could not merge symlinks to merged description: "
773  << "symlink types: ";
774  for (unsigned int i = 0; i < symlinkTypes.size(); ++i) {
775  msg() << MSG::ERROR << symlinkTypes[i] << " ";
776  }
777  msg() << MSG::ERROR << endmsg;
778  return( StatusCode::FAILURE);
779  }
780  else {
781  ATH_MSG_DEBUG ("symlinks, merged names "
782  << symlinkTypes << " " << mergedNames);
783  }
784  }
785 
786  // Type of time is defined by start/stop
787 
788  // Some checks on the times:
789  if (!start.isValid() ||
790  !stop.isValid() ||
791  start.isTimestamp() != stop.isTimestamp() ||
792  start.isRunEvent() != stop.isRunEvent()) {
793  ATH_MSG_ERROR ("Invalid times: start isValid/isTimeStamp/isRunEvent "
794  << "addrHeader: " << address_header
795  << start.isValid() << " " << start.isTimestamp() << " "
796  << start.isRunEvent());
797  ATH_MSG_ERROR ("Invalid times: stop isValid/isTimeStamp/isRunEvent "
798  << "addrHeader: " << address_header
799  << stop.isValid() << " " << stop.isTimestamp() << " "
800  << stop.isRunEvent());
801  return( StatusCode::FAILURE);
802  }
803  bool isTimeStamp = false;
804  if (start.isTimestamp()) isTimeStamp = true;
805 
806  if (isTimeStamp)
807  {
808  sc = buildDescription( "timeStamp", "time",
809  mergedNames );
810  }
811  else
812  {
813  sc = buildDescription( "timeStamp", "run-lumi",
814  mergedNames );
815  }
816  if (sc.isFailure()) {
817  ATH_MSG_ERROR ("Could not merge timeStamp flag towards merged description. ");
818  return( StatusCode::FAILURE);
819  }
820  // add <named/> for channels with names
821  if (storeAttrListColl && attrListColl!=0 &&
822  attrListColl->name_size()>0) mergedNames+="<named/>";
823 
824  ATH_MSG_DEBUG (" create folder " << local_folder
825  << " with description " << mergedNames);
826 
827  // Create folder
828 
829  ATH_MSG_DEBUG ("Set attr list coll ptr " << attrListColl);
830 
831  cool::RecordSpecification payloadSpec;
832  if (storeRef) {
833  // Folder with refs only:
834  // Payload specification - contains just a string
835  // assuming POOL refs will not be longer than 4000 chars
836  payloadSpec.extend("PoolRef",cool::StorageType::String4k);
837  }
838  else {
839  // Store AttributeList or a collection of AttributeLists
840  const coral::AttributeList* atr4spec=0;
841  if (storeAttrListColl) {
842 
843  // Folder with CondAttrListCollection itself
844  // Get the attribute spec from the first element in the collection
845  if (0 == attrListColl) {
846  ATH_MSG_ERROR ("attrListColl not found. ");
847  return( StatusCode::FAILURE);
848  }
849 
850  if (0 == attrListColl->size()) {
851  ATH_MSG_ERROR ("attrListColl is empty. ");
852  return( StatusCode::FAILURE);
853  }
854  // FIXME
855  ATH_MSG_DEBUG ("Size of AttrList collection" <<
856  attrListColl->size());
857 
858  atr4spec=&((*attrListColl->begin()).second);
859  } else {
860  // folder with simple AttributeList
861  atr4spec=attrList;
862  ATH_MSG_DEBUG ("In simple atrlist branch");
863  }
864  ATH_MSG_DEBUG ("Pointer to atrList is " << atr4spec);
865  // construct COOL specification
866  for (coral::AttributeList::const_iterator itr=
867  atr4spec->begin();itr!=atr4spec->end();++itr) {
868  // extend specification with appropriate COOL type
869  // giving opportunity to override default choice
870  payloadSpec.extend(itr->specification().name(),
871  coralToCoolType(itr->specification().name(),
872  itr->specification().typeName()));
873  }
874  }
875  // create folder
876  cool::FolderVersioning::Mode version=
877  cool::FolderVersioning::MULTI_VERSION;
878  if (m_svFolder) {
879  version=cool::FolderVersioning::SINGLE_VERSION;
880  ATH_MSG_INFO ("Creating single version folder for "
881  << local_folder);
882  }
883  if (m_payloadTable)
884  ATH_MSG_INFO ("Creating separate payload table for "
885  << local_folder);
886  cool::FolderSpecification folderSpec(version,payloadSpec,cool::PayloadMode::SEPARATEPAYLOAD);
887  folder = db->createFolder(local_folder,folderSpec,
888  mergedNames,true);
889  ATH_MSG_DEBUG ("Creation of CondDBFolder " <<
890  local_folder << " done");
891 
892  // create channels if needed - only for CondAttrListColl with names
893  if (storeAttrListColl && attrListColl!=0 &&
894  attrListColl->name_size()>0) {
895  ATH_MSG_DEBUG ("Naming " << attrListColl->name_size() <<
896  " channels in " << local_folder);
897  for (CondAttrListCollection::name_const_iterator nitr=
898  attrListColl->name_begin();
899  nitr!=attrListColl->name_end();++nitr) {
900  folder->createChannel(nitr->first,nitr->second);
901  }
902  }
903  }
904 
905  // Print out stop/start ONLY for non-collections - collections
906  // have a per-channel start/stop
907  if (storeAttrListColl) {
908  ATH_MSG_DEBUG (" Global Start/stop time: "
909  << start << " " << stop << " Note: will be ignored for channels with differnt IOVs " );
910  }
911  else {
912  ATH_MSG_DEBUG (" Start/stop time " << start << " " << stop << " ");
913  }
914 
915  // Convert IOVTime to ValidityKey
916  cool::ValidityKey ivStart = start.re_time();
917  cool::ValidityKey ivStop = stop.re_time();
918  if(start.isTimestamp()) {
919  ivStart = start.timestamp();
920  ivStop = stop.timestamp();
921  }
922 
923  // get record specification of folder
924 
925  const cool::RecordSpecification& rspec=folder->payloadSpecification();
926 
927  if (storeAttrListColl) {
928  //
929  // Need to store multiple channels
930  //
931  // The policy for the IOV of each channel is to use the
932  // channel IOV already stored in the collection, if it is
933  // there. If it is not there, then use the global IOV.
934  //
935  if (storeRef) {
936  // Should NOT get here for a collection, signal error
937  ATH_MSG_ERROR ("Trying to store a ref for a CondAttrListCollection. ");
938  return( StatusCode::FAILURE);
939  }
940 
941  ATH_MSG_DEBUG (" --> Storing Object( " << start << ", " << stop
942  << ", " << tag << " )");
943  ATH_MSG_DEBUG (" --> address: " << address_data);
944  // Loop over collection
945  CondAttrListCollection::const_iterator first = attrListColl->begin();
946  CondAttrListCollection::const_iterator last = attrListColl->end();
947  for (; first != last; ++first) {
948 
949  // Copy from retrieved attribute list
950  const coral::AttributeList& payload = (*first).second;
951  // Get channel id
952  CondAttrListCollection::ChanNum chanNum = (*first).first;
953 
954  // Check whether to use already stored IOV, or the
955  // global IOV
956  cool::ValidityKey ivStart1 = ivStart;
957  cool::ValidityKey ivStop1 = ivStop;
958  CondAttrListCollection::iov_const_iterator iovIt = attrListColl->chanIOVPair(chanNum);
959  std::ostringstream attr;
960  payload.toOutputStream( attr );
961  ATH_MSG_DEBUG (" --> ChanNum: " << chanNum << " Payload: " << attr.str());
962  if (!m_forceGlobalIOV && iovIt != attrListColl->iov_end()) {
963  const IOVRange& range = (*iovIt).second;
964  if(range.start().isTimestamp()) {
965  ivStart1 = range.start().timestamp();
966  ivStop1 = range.stop().timestamp();
967  }
968  else {
969  ivStart1 = range.start().re_time();
970  ivStop1 = range.stop().re_time();
971  }
972  ATH_MSG_DEBUG (" --> Start/stop time "
973  << range.start() << " " << range.stop() << " ");
974  }
975  else {
976  ATH_MSG_DEBUG (" --> Start/stop time "
977  << start << " " << stop << " ");
978  }
979 
980  // Store address in folder with interval
981  cool::Record record(rspec,payload);
982  if (m_userTags && tag!="") {
983  ATH_MSG_DEBUG ("Object stored with user tag " << tag );
984  folder->storeObject( ivStart1,
985  ivStop1,
986  record,
987  chanNum,tag,!m_userTagsUH);
988  } else {
989  folder->storeObject( ivStart1,
990  ivStop1,
991  record,
992  chanNum);
993  }
994  }
995  }
996  else {
997  // Store a single channel
998  cool::Record record(rspec);
999  if (storeRef) {
1000  // PayLoad is ONLY the ref
1001  record["PoolRef"].setValue<std::string>(address_data);
1002  }
1003  else {
1004  // Copy from retrieved attribute list
1005  record=cool::Record(rspec,*attrList);
1006  }
1007 
1008  // Store address in folder with interval
1009  if (m_userTags && tag!="") {
1010  ATH_MSG_DEBUG ("Object stored with user tag " << tag );
1011  folder->storeObject( ivStart,
1012  ivStop,
1013  record,0,tag,!m_userTagsUH);
1014  } else {
1015  folder->storeObject( ivStart,
1016  ivStop,
1017  record,0);
1018  }
1019 
1020  ATH_MSG_DEBUG (" --> Stored Object( " << start << ", " << stop
1021  << ", " << tag << " )");
1022  ATH_MSG_DEBUG (" --> address: " << address_data);
1023  }
1024 
1025  ATH_MSG_DEBUG (" storeData OK ");
1026 
1027  // Now tag the folder if required
1028  if (!m_userTags) {
1029  if ("" == tag) {
1030  ATH_MSG_DEBUG (" tag is empty - folder is not being tagged ");
1031  }
1032  else {
1033  ATH_MSG_INFO (" Tagging HEAD of folder " << local_folder <<
1034  " with tag " << tag);
1035  try {
1036  folder->tagCurrentHead(tag,m_tagDescription);
1037  }
1038  catch ( cool::TagExists& e) {
1039  ATH_MSG_INFO ("Tag " << tag <<
1040  " exists - attempt to delete tag and retag HEAD");
1041  // first check this tag is really defined in THIS folder
1042  std::vector<std::string> taglist=folder->listTags();
1043  if (find(taglist.begin(),taglist.end(),tag)==
1044  taglist.end()) {
1045  ATH_MSG_ERROR ("Tag is defined in another folder - tag names must be global");
1046  } else if (folder->existsUserTag(tag)) {
1047  // this is a COOL user tag, in which case user
1048  // is trying to mix user and HEAD tags, not allowed in COOL1.3
1049  ATH_MSG_ERROR ("Tag " << tag <<
1050  " is already USER tag - cannot mix tagging modes");
1051  } else {
1052  try {
1053  folder->deleteTag(tag);
1054  folder->tagCurrentHead(tag,m_tagDescription);
1055  ATH_MSG_INFO ("Delete and retag succeeded");
1056  }
1057  catch ( cool::TagNotFound& e) {
1058  ATH_MSG_ERROR ("Delete and retag HEAD failed");
1059  }
1060  }
1061  }
1062  }
1063  }
1064  return StatusCode::SUCCESS;
1065  }
1066 
1067  catch (std::exception& e) {
1068  ATH_MSG_ERROR ("*** COOL exception caught: " << e.what() );
1069  // << "\n"
1070  // << "*** error code: " << e.code()
1071  return StatusCode::FAILURE;
1072  }
1073 
1074  //return StatusCode::SUCCESS;
1075 }

◆ splitAddress()

StatusCode IOVRegistrationSvc::splitAddress ( const std::string &  address,
std::string &  address_header,
std::string &  address_data 
) const
private

Split address in its header and data parts.

Definition at line 1142 of file IOVRegistrationSvc.cxx.

1144  {
1145  // this routine was originally in IOVDbSvc, moved here as only client
1146  // Deals with address of form
1147  // <address_header service_type="256" clid="1238547719" /> POOLContainer_CondAttrListCollection][CLID=x
1148  // return header as part up to and including />, trailer as rest
1149 
1150  std::string::size_type p1=address.find(" />");
1151  if (p1!=std::string::npos) {
1152  address_header=address.substr(0,p1+3);
1153  address_data=address.substr(p1+4);
1154  return StatusCode::SUCCESS;
1155  } else {
1156  return StatusCode::FAILURE;
1157  }
1158 }

◆ timeToNano()

uint64_t IOVRegistrationSvc::timeToNano ( const unsigned long int  timesec) const
private

Definition at line 1118 of file IOVRegistrationSvc.cxx.

1119 {
1120  // convert time specified in seconds to ns used by COOL
1121  // use the magic value MAXEVENT to signal full range
1122  if (timesec==IOVTime::MAXEVENT) {
1123  return IOVTime::MAXTIMESTAMP;
1124  } else {
1125  return static_cast<uint64_t>(timesec)*1000000000;
1126  }
1127 }

◆ type()

const InterfaceID & IOVRegistrationSvc::type ( ) const
virtual

Service type.

Definition at line 63 of file IOVRegistrationSvc.cxx.

65 {
66  return IIOVRegistrationSvc::interfaceID();
67 }

Friends And Related Function Documentation

◆ SvcFactory< IOVRegistrationSvc >

friend class SvcFactory< IOVRegistrationSvc >
friend

Definition at line 142 of file IOVRegistrationSvc.h.

Member Data Documentation

◆ m_beginLB

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_beginLB {this, "BeginLB", IOVTime::MINEVENT}
private

Definition at line 187 of file IOVRegistrationSvc.h.

◆ m_beginRun

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_beginRun {this, "BeginRun", IOVTime::MINRUN}
private

Definition at line 185 of file IOVRegistrationSvc.h.

◆ m_beginTime

Gaudi::Property<unsigned long> IOVRegistrationSvc::m_beginTime {this, "BeginTime", IOVTime::MINTIMESTAMP}
private

Definition at line 190 of file IOVRegistrationSvc.h.

◆ m_clidSvc

ServiceHandle<IClassIDSvc> IOVRegistrationSvc::m_clidSvc
private

Definition at line 208 of file IOVRegistrationSvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> IOVRegistrationSvc::m_detStore
private

Definition at line 206 of file IOVRegistrationSvc.h.

◆ m_endLB

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_endLB {this, "EndLB", IOVTime::MAXEVENT}
private

Definition at line 188 of file IOVRegistrationSvc.h.

◆ m_endRun

Gaudi::Property<unsigned int> IOVRegistrationSvc::m_endRun {this, "EndRun", IOVTime::MAXRUN}
private

Definition at line 186 of file IOVRegistrationSvc.h.

◆ m_endTime

Gaudi::Property<unsigned long> IOVRegistrationSvc::m_endTime {this, "EndTime", IOVTime::MAXEVENT}
private

Definition at line 191 of file IOVRegistrationSvc.h.

◆ m_forceGlobalIOV

Gaudi::Property<bool> IOVRegistrationSvc::m_forceGlobalIOV {this, "UseGlobalIOVForCollections", false}
private

Definition at line 201 of file IOVRegistrationSvc.h.

◆ m_iov_db

ServiceHandle<IIOVCondDbSvc> IOVRegistrationSvc::m_iov_db
private

Definition at line 205 of file IOVRegistrationSvc.h.

◆ m_overrideName

Gaudi::Property<std::vector<std::string> > IOVRegistrationSvc::m_overrideName {this, "OverrideNames", {}}
private

Definition at line 202 of file IOVRegistrationSvc.h.

◆ m_overrideType

Gaudi::Property<std::vector<std::string> > IOVRegistrationSvc::m_overrideType {this, "OverrideTypes", {}}
private

Definition at line 203 of file IOVRegistrationSvc.h.

◆ m_payloadTable

Gaudi::Property<bool> IOVRegistrationSvc::m_payloadTable {this, "PayloadTable", false}
private

Definition at line 200 of file IOVRegistrationSvc.h.

◆ m_persSvc

ServiceHandle<IAddressCreator> IOVRegistrationSvc::m_persSvc
private

Definition at line 207 of file IOVRegistrationSvc.h.

◆ m_recreateFolders

Gaudi::Property<bool> IOVRegistrationSvc::m_recreateFolders {this, "RecreateFolders", false}
private

Definition at line 184 of file IOVRegistrationSvc.h.

◆ m_svFolder

Gaudi::Property<bool> IOVRegistrationSvc::m_svFolder {this, "SVFolder", false}
private

Definition at line 199 of file IOVRegistrationSvc.h.

◆ m_tag

Gaudi::Property<std::string> IOVRegistrationSvc::m_tag {this, "IOVDbTag", ""}
private

Definition at line 193 of file IOVRegistrationSvc.h.

◆ m_tagDescription

Gaudi::Property<std::string> IOVRegistrationSvc::m_tagDescription {this, "TagDescription", "Athena IOVRegistrationSvc"}
private

Definition at line 195 of file IOVRegistrationSvc.h.

◆ m_timeStamp

Gaudi::Property<bool> IOVRegistrationSvc::m_timeStamp {this, "IOVDbTimeStamp", false}
private

Definition at line 194 of file IOVRegistrationSvc.h.

◆ m_userTags

Gaudi::Property<bool> IOVRegistrationSvc::m_userTags {this, "userTags", true}
private

Definition at line 197 of file IOVRegistrationSvc.h.

◆ m_userTagsUH

Gaudi::Property<bool> IOVRegistrationSvc::m_userTagsUH {this, "userTagsUpdateHead", false}
private

Definition at line 198 of file IOVRegistrationSvc.h.

◆ m_writeKeyInfo

Gaudi::Property<bool> IOVRegistrationSvc::m_writeKeyInfo {this, "writeKeyInfo", true}
private

Definition at line 196 of file IOVRegistrationSvc.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
IOVRegistrationSvc::m_timeStamp
Gaudi::Property< bool > m_timeStamp
Definition: IOVRegistrationSvc.h:194
IOVRegistrationSvc::m_userTags
Gaudi::Property< bool > m_userTags
Definition: IOVRegistrationSvc.h:197
CondAttrListCollection::end
const_iterator end() const
Definition: CondAttrListCollection.h:315
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IOVRange
Validity Range object. Holds two IOVTimes (start and stop)
Definition: IOVRange.h:30
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
CondAttrListCollection::iov_end
iov_const_iterator iov_end() const
Definition: CondAttrListCollection.h:343
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
IOVRegistrationSvc::m_overrideName
Gaudi::Property< std::vector< std::string > > m_overrideName
Definition: IOVRegistrationSvc.h:202
IOVRegistrationSvc::m_recreateFolders
Gaudi::Property< bool > m_recreateFolders
Definition: IOVRegistrationSvc.h:184
initialize
void initialize()
Definition: run_EoverP.cxx:894
CaloCondBlobAlgs_fillNoiseFromASCII.db
db
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:42
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
python.CreateTierZeroArgdict.parname
parname
Definition: CreateTierZeroArgdict.py:194
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
IOVRegistrationSvc::m_overrideType
Gaudi::Property< std::vector< std::string > > m_overrideType
Definition: IOVRegistrationSvc.h:203
skel.it
it
Definition: skel.GENtoEVGEN.py:407
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
CondAttrListCollection::begin
const_iterator begin() const
Access to Chan/AttributeList pairs via iterators.
Definition: CondAttrListCollection.h:309
CheckTagAssociation.taglist
taglist
Definition: CheckTagAssociation.py:103
athena.value
value
Definition: athena.py:124
CopyBlobFromCool.payloadSpec
payloadSpec
Definition: CopyBlobFromCool.py:114
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
IOVRegistrationSvc::registerIOVCOOL
StatusCode registerIOVCOOL(const std::string &typeName, const std::string &key, const std::string &folderName, const std::string &tag, const IOVTime &begin, const IOVTime &end) const
Definition: IOVRegistrationSvc.cxx:435
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
xAOD::identifier
identifier
Definition: UncalibratedMeasurement_v1.cxx:15
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
CaloTime_fillDB.folderSpec
folderSpec
Definition: CaloTime_fillDB.py:90
CondAttrListCollection::iov_const_iterator
ChanIOVMap::const_iterator iov_const_iterator
Definition: CondAttrListCollection.h:66
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
IOVRegistrationSvc::splitAddress
StatusCode splitAddress(const std::string &address, std::string &address_header, std::string &address_data) const
Split address in its header and data parts.
Definition: IOVRegistrationSvc.cxx:1142
CondAttrListCollAddress
This class provides the an IOpaqueAddress/GenericAddress which can hold a pointer to an CondAttrListC...
Definition: CondAttrListCollAddress.h:27
CondAttrListCollection::name_const_iterator
ChanNameMap::const_iterator name_const_iterator
Definition: CondAttrListCollection.h:69
IOVTime
Basic time unit for IOVSvc. Hold time as a combination of run and event numbers.
Definition: IOVTime.h:33
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IOVRegistrationSvc::m_beginLB
Gaudi::Property< unsigned int > m_beginLB
Definition: IOVRegistrationSvc.h:187
checkCoolLatestUpdate.chanNum
chanNum
Definition: checkCoolLatestUpdate.py:26
IOVRegistrationSvc::m_iov_db
ServiceHandle< IIOVCondDbSvc > m_iov_db
Definition: IOVRegistrationSvc.h:205
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
calibdata.exception
exception
Definition: calibdata.py:495
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
IOVTime::MAXTIMESTAMP
static constexpr uint64_t MAXTIMESTAMP
Definition: IOVTime.h:58
IOVRegistrationSvc::coralToCoolType
cool::StorageType::TypeId coralToCoolType(const std::string &parname, const std::string &coralName) const
Definition: IOVRegistrationSvc.cxx:1077
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table. The name and type of eac...
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:45
IOVRegistrationSvc::m_beginTime
Gaudi::Property< unsigned long > m_beginTime
Definition: IOVRegistrationSvc.h:190
IOVRegistrationSvc::m_forceGlobalIOV
Gaudi::Property< bool > m_forceGlobalIOV
Definition: IOVRegistrationSvc.h:201
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
IOVRegistrationSvc::m_beginRun
Gaudi::Property< unsigned int > m_beginRun
Definition: IOVRegistrationSvc.h:185
IOVRegistrationSvc::m_endLB
Gaudi::Property< unsigned int > m_endLB
Definition: IOVRegistrationSvc.h:188
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
IOVRegistrationSvc::m_endRun
Gaudi::Property< unsigned int > m_endRun
Definition: IOVRegistrationSvc.h:186
CondAttrListCollection::ChanNum
unsigned int ChanNum
Definition: CondAttrListCollection.h:55
IOVRegistrationSvc::m_persSvc
ServiceHandle< IAddressCreator > m_persSvc
Definition: IOVRegistrationSvc.h:207
CondAttrListCollection::name_begin
name_const_iterator name_begin() const
Access to Chan/Name pairs via iterators.
Definition: CondAttrListCollection.h:364
IOVTime::MAXEVENT
static constexpr uint32_t MAXEVENT
Definition: IOVTime.h:51
CondAttrListCollection::name_size
name_size_type name_size() const
number of Chan/Name pairs
Definition: CondAttrListCollection.h:377
CondAttrListCollAddress::attrListColl
CondAttrListCollection * attrListColl()
Access to AttributeList.
Definition: CondAttrListCollAddress.h:120
CaloCellTimeCorrFiller.folderName
string folderName
Definition: CaloCellTimeCorrFiller.py:19
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
EventContainers::Mode
Mode
Definition: IdentifiableContainerBase.h:13
RTTAlgmain.address
address
Definition: RTTAlgmain.py:55
CondAttrListCollection::size
size_type size() const
number of Chan/AttributeList pairs
Definition: CondAttrListCollection.h:322
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
IOVRegistrationSvc::m_clidSvc
ServiceHandle< IClassIDSvc > m_clidSvc
Definition: IOVRegistrationSvc.h:208
IOVRegistrationSvc::buildDescription
virtual StatusCode buildDescription(const std::string &identifier, const std::string &value, std::string &description) const
Build the folder description field add in front of the description the value with identifier-markups.
Definition: IOVRegistrationSvc.cxx:1129
IOVRegistrationSvc::type
virtual const InterfaceID & type() const
Service type.
Definition: IOVRegistrationSvc.cxx:63
get_generator_info.version
version
Definition: get_generator_info.py:33
IOVRegistrationSvc::m_userTagsUH
Gaudi::Property< bool > m_userTagsUH
Definition: IOVRegistrationSvc.h:198
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CondAttrListCollection::const_iterator
ChanAttrListMap::const_iterator const_iterator
Definition: CondAttrListCollection.h:63
IOVRegistrationSvc::m_payloadTable
Gaudi::Property< bool > m_payloadTable
Definition: IOVRegistrationSvc.h:200
IOVRegistrationSvc::registerIOV
virtual StatusCode registerIOV(const std::string &typeName) const
Register IOV DB for an object given its typeName - run/LB numbers interval or times interval and tag ...
Definition: IOVRegistrationSvc.cxx:151
DeMoScan.first
bool first
Definition: DeMoScan.py:534
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:55
ReadCalibFromCool.typeName
typeName
Definition: ReadCalibFromCool.py:477
IOVRegistrationSvc::m_writeKeyInfo
Gaudi::Property< bool > m_writeKeyInfo
Definition: IOVRegistrationSvc.h:196
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
CondAttrListCollection::chanIOVPair
iov_const_iterator chanIOVPair(ChanNum chanNum) const
Access to Chan/IOV pairs via channel number: returns map iterator.
Definition: CondAttrListCollection.h:330
IOVRegistrationSvc::m_svFolder
Gaudi::Property< bool > m_svFolder
Definition: IOVRegistrationSvc.h:199
SG::DataProxy
Definition: DataProxy.h:45
IOVRegistrationSvc::m_tag
Gaudi::Property< std::string > m_tag
Definition: IOVRegistrationSvc.h:193
IOVRegistrationSvc::m_endTime
Gaudi::Property< unsigned long > m_endTime
Definition: IOVRegistrationSvc.h:191
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
IOVRegistrationSvc::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: IOVRegistrationSvc.h:206
IOVRegistrationSvc::timeToNano
uint64_t timeToNano(const unsigned long int timesec) const
Definition: IOVRegistrationSvc.cxx:1118
lumiFormat.endTime
endTime
Definition: lumiFormat.py:100
IOVRegistrationSvc::m_tagDescription
Gaudi::Property< std::string > m_tagDescription
Definition: IOVRegistrationSvc.h:195
CondAttrListCollection::name_end
name_const_iterator name_end() const
Definition: CondAttrListCollection.h:370
description
std::string description
glabal timer - how long have I taken so far?
Definition: hcg.cxx:88
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Sep 2 2025 21:40:42 for ATLAS Offline Software by   doxygen 1.8.18