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

BooleanProperty m_recreateFolders
 
UnsignedIntegerProperty m_beginRun
 
UnsignedIntegerProperty m_endRun
 
UnsignedIntegerProperty m_beginLB
 
UnsignedIntegerProperty m_endLB
 
UnsignedLongProperty m_beginTime
 
UnsignedLongProperty m_endTime
 
StringProperty m_tag
 
BooleanProperty m_timeStamp
 
StringProperty m_tagDescription
 
BooleanProperty m_writeKeyInfo
 
BooleanProperty m_userTags
 
BooleanProperty m_userTagsUH
 
BooleanProperty m_svFolder
 
BooleanProperty m_payloadTable
 
BooleanProperty m_forceGlobalIOV
 
std::vector< std::string > m_overrideName
 
std::vector< std::string > m_overrideType
 
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 52 of file IOVRegistrationSvc.h.

Constructor & Destructor Documentation

◆ IOVRegistrationSvc()

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

Definition at line 51 of file IOVRegistrationSvc.cxx.

52  :
53  base_class( name, svc ),
54  m_recreateFolders(false),
55  m_beginRun(IOVTime::MINRUN),
56  m_endRun(IOVTime::MAXRUN),
57  m_beginLB(IOVTime::MINEVENT),
58  m_endLB(IOVTime::MAXEVENT),
59  m_beginTime(IOVTime::MINTIMESTAMP),
60  m_endTime(IOVTime::MAXEVENT), // as the time parameter is only 32bit
61  m_tag(""),
62  m_timeStamp(false),
63  m_tagDescription("Athena IOVRegistrationSvc"),
64  m_writeKeyInfo(true),
65  m_userTags(true),
66  m_userTagsUH(false),
67  m_svFolder(false),
68  m_payloadTable(false),
69  m_forceGlobalIOV(false),
70  m_iov_db ( "IOVDbSvc", name ),
71  m_detStore( "DetectorStore", name ),
72  m_persSvc ( "EventPersistencySvc", name ),
73  m_clidSvc ( "ClassIDSvc", name )
74 {
75 
76  // Declare properties
77  declareProperty("RecreateFolders", m_recreateFolders);
78  declareProperty("BeginRun", m_beginRun);
79  declareProperty("EndRun", m_endRun);
80  declareProperty("BeginLB", m_beginLB);
81  declareProperty("EndLB", m_endLB);
82  declareProperty("BeginTime", m_beginTime);
83  declareProperty("EndTime", m_endTime);
84  declareProperty("IOVDbTag", m_tag);
85  declareProperty("IOVDbTimeStamp", m_timeStamp);
86  declareProperty("TagDescription", m_tagDescription);
87  declareProperty("writeKeyInfo", m_writeKeyInfo);
88  declareProperty("userTags", m_userTags);
89  declareProperty("userTagsUpdateHead",m_userTagsUH);
90  declareProperty("SVFolder", m_svFolder);
91  declareProperty("PayloadTable", m_payloadTable);
92  declareProperty("OverrideNames", m_overrideName);
93  declareProperty("OverrideTypes", m_overrideType);
94  declareProperty("UseGlobalIOVForCollections", m_forceGlobalIOV);
95 }

◆ ~IOVRegistrationSvc()

IOVRegistrationSvc::~IOVRegistrationSvc ( )
virtual

Definition at line 98 of file IOVRegistrationSvc.cxx.

99 {}

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 1167 of file IOVRegistrationSvc.cxx.

1169  {
1170  // this routine was originally in IOVDbSvc, moved here as only client
1171  // buids an XML fragment of form <identifier>value</identifier>
1172  if (identifier.empty() || value.empty()) {
1173  ATH_MSG_ERROR ("Identifier or value is null.");
1174  return StatusCode::FAILURE;
1175  }
1176  description = "<"+identifier+">"+value+"</"+identifier+">"+description;
1177  return StatusCode::SUCCESS;
1178 }

◆ coralToCoolType()

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

Definition at line 1115 of file IOVRegistrationSvc.cxx.

1116  {
1117  // map coral type onto corresponding COOL storage type
1118  std::string coralType=coralName;
1119  // check for any overrides
1120  for (unsigned int i=0;i<m_overrideType.size();++i) {
1121  if (m_overrideName[i]==parname) {
1122  coralType=m_overrideType[i];
1123  ATH_MSG_INFO ("Override default type for attribute " <<
1124  parname << " - use " << coralType);
1125  }
1126  }
1127  // FIXME to include all CORAL/COOL types
1128  // give both the names of CORAL types, and COOL types which may get specified
1129  // as overrides
1130  if (coralType=="bool") return cool::StorageType::Bool;
1131  if (coralType=="UChar" || coralType=="unsigned char") return cool::StorageType::UChar;
1132  if (coralType=="Int16") return cool::StorageType::Int16;
1133  if (coralType=="UInt16") return cool::StorageType::UInt16;
1134  if (coralType=="Int32" || coralType=="int") return cool::StorageType::Int32;
1135  if (coralType=="UInt32" || coralType=="unsigned int") return cool::StorageType::UInt32;
1136  if (coralType=="UInt63" || coralType=="unsigned long long") return cool::StorageType::UInt63;
1137  if (coralType=="Int64" || coralType=="long long") return cool::StorageType::Int64;
1138  if (coralType=="Float" || coralType=="float") return cool::StorageType::Float;
1139  if (coralType=="Double" || coralType=="double") return cool::StorageType::Double;
1140  if (coralType=="String255") return cool::StorageType::String255;
1141  if (coralType=="String4k" || coralType=="string") return cool::StorageType::String4k;
1142  if (coralType=="String64k") return cool::StorageType::String64k;
1143  if (coralType=="String16M") return cool::StorageType::String16M;
1144  if (coralType=="blob" || coralType=="Blob64k")
1145  return cool::StorageType::Blob64k;
1146  if (coralType=="Blob16M") return cool::StorageType::Blob16M;
1147 
1148  // if we get here, mapping is undefined
1149  ATH_MSG_FATAL ("No COOL mapping defined for CORAL type " << coralName);
1150  throw std::exception();
1151 }

◆ finalize()

StatusCode IOVRegistrationSvc::finalize ( )
virtual

Finalize AlgTool.

Definition at line 182 of file IOVRegistrationSvc.cxx.

183 {
184  return StatusCode::SUCCESS;
185 }

◆ 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 109 of file IOVRegistrationSvc.cxx.

110 {
111  ATH_MSG_DEBUG ("in initialize()");
112 
113  StatusCode sc = AthService::initialize();
114  if ( sc.isFailure() ) {
115  ATH_MSG_ERROR ("Unable to call base initialize method");
116  return StatusCode::FAILURE;
117  }
118 
119  // locate the conditions store ptr to it.
120  sc = m_detStore.retrieve();
121  if (!sc.isSuccess() || 0 == m_detStore) {
122  ATH_MSG_ERROR ("Could not find ConditionStore");
123  return StatusCode::FAILURE;
124  }
125 
126  // Get the IOVDbSvc
127  sc = m_iov_db.retrieve();
128  if ( sc.isFailure() ) {
129  ATH_MSG_ERROR ("Unable to get the IOVDbSvc");
130  return StatusCode::FAILURE;
131  }
132 
133  // Get the persistency mgr for conversion of IOpaqueAddress to
134  // string
135  sc = m_persSvc.retrieve();
136  if ( sc != StatusCode::SUCCESS ) {
137  ATH_MSG_ERROR (" Cannot get IAddressCreator interface of the EventPersistencySvc ");
138  return sc ;
139  }
140  ATH_MSG_DEBUG ("Found PersistencySvc ");
141 
142 
143  // Get the ClassIDSvc - to get typename for clid
144  sc = m_clidSvc.retrieve();
145  if (sc != StatusCode::SUCCESS ) {
146  ATH_MSG_ERROR (" Cannot get IClassIDSvc interface of the CLIDSvc " );
147  return sc ;
148  }
149  ATH_MSG_DEBUG ("Found CLIDSvc ");
150 
151 
152  ATH_MSG_DEBUG ("Properties ");
153  ATH_MSG_DEBUG ("RecreateFolders " << m_recreateFolders);
154  if (m_timeStamp)
155  {
156  ATH_MSG_DEBUG ("BeginTime " << m_beginTime);
157  ATH_MSG_DEBUG ("EndTime " << m_endTime);
158  }
159  else
160  {
161  ATH_MSG_DEBUG ("BeginRun " << m_beginRun);
162  ATH_MSG_DEBUG ("EndRun " << m_endRun);
163  ATH_MSG_DEBUG ("BeginLB " << m_beginLB);
164  ATH_MSG_DEBUG ("EndLB " << m_endLB);
165  }
166  ATH_MSG_DEBUG ("IOVDbTag " << m_tag);
167 
168  // check consistency of override specification, if any
169  if (m_overrideName.size()!=m_overrideType.size()) {
170  ATH_MSG_FATAL ("Inconsistent settings of OverrideNames and OverrideTypes parameters");
171  return StatusCode::FAILURE;
172  }
173  for (unsigned int i=0;i<m_overrideName.size();++i)
174  ATH_MSG_INFO ("Attributes with name " << m_overrideName[i] <<
175  " will be stored as COOL type " << m_overrideType[i]);
176  return StatusCode::SUCCESS;
177 
178 }

◆ 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 189 of file IOVRegistrationSvc.cxx.

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

◆ 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 425 of file IOVRegistrationSvc.cxx.

431 {
432  // Register the conditions objects in the IOV database with
433  // start/stop as the time interval
434 
435 
436  msg() << MSG::DEBUG <<" in registerIOV()"
437  << " typename: " << typeName << " - tag: " << tag;
438  if (spec_key.empty())
439  {
440  msg() << " key: *empty* " << endmsg;
441  }
442  else
443  {
444  msg() << " spec_key " << spec_key << endmsg;
445  }
446  msg() << " - begin time: " << start
447  << " - end time: " << stop
448  << endmsg;
449 
450  // Check validity of start/stop
451  if(start.isBoth() || stop.isBoth() ||
452  start.isTimestamp() != stop.isTimestamp() ||
453  start.isRunEvent() != stop.isRunEvent()) {
454  ATH_MSG_ERROR ("Incorrect start/stop: "
455  << " isBoth: " << start.isBoth() << ":" << stop.isBoth()
456  << " isTimestamp: " << start.isTimestamp() << ":" << stop.isTimestamp()
457  << " isRunEvent: " << start.isRunEvent() << ":" << stop.isRunEvent());
458  return( StatusCode::FAILURE);
459  }
460 
461  return registerIOVCOOL( typeName,
462  spec_key,
463  folder,
464  tag,
465  start,
466  stop );
467 }

◆ 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 399 of file IOVRegistrationSvc.cxx.

405 {
406  IOVTime start;
407  start.setTimestamp( beginTime );
408  IOVTime stop;
409  stop.setTimestamp ( endTime );
410 
411  return ( registerIOV( typeName,
412  key,
413  folder,
414  tag,
415  start,
416  stop) );
417 }

◆ 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 375 of file IOVRegistrationSvc.cxx.

383 {
384  IOVTime start;
385  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
386  IOVTime stop;
387  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
388 
389  return ( registerIOV( typeName,
390  key,
391  folder,
392  tag,
393  start,
394  stop) );
395 }

◆ 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 257 of file IOVRegistrationSvc.cxx.

259 {
260  if (m_timeStamp)
261  {
262  IOVTime start;
263  start.setTimestamp( timeToNano(m_beginTime) );
264  IOVTime stop ;
265  stop.setTimestamp ( timeToNano(m_endTime) );
266 
267  return ( registerIOV( typeName,
268  key,key,
269  tag,
270  start,
271  stop) );
272  }
273  else
274  {
275  IOVTime start;
276  start.setRunEvent( (unsigned long)m_beginRun, (unsigned long)m_beginLB );
277  IOVTime stop;
278  stop.setRunEvent ( (unsigned long)m_endRun, (unsigned long)m_endLB );
279 
280  return ( registerIOV( typeName,
281  key,key,
282  tag,
283  start,
284  stop) );
285  }
286 }

◆ 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 355 of file IOVRegistrationSvc.cxx.

360 {
361  IOVTime start;
362  start.setTimestamp( beginTime );
363  IOVTime stop;
364  stop.setTimestamp ( endTime );
365 
366  return ( registerIOV( typeName,
367  key,key,
368  tag,
369  start,
370  stop) );
371 }

◆ 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 333 of file IOVRegistrationSvc.cxx.

340 {
341  IOVTime start;
342  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
343  IOVTime stop;
344  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
345 
346  return ( registerIOV( typeName,
347  key,key,
348  tag,
349  start,
350  stop) );
351 }

◆ 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 223 of file IOVRegistrationSvc.cxx.

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

◆ 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 312 of file IOVRegistrationSvc.cxx.

316 {
317  IOVTime start;
318  start.setTimestamp( beginTime );
319  IOVTime stop;
320  stop.setTimestamp ( endTime );
321 
322  std::string key = "";
323 
324  return ( registerIOV( typeName,
325  key,key,
326  tag,
327  start,
328  stop) );
329 }

◆ 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 290 of file IOVRegistrationSvc.cxx.

296 {
297  IOVTime start;
298  start.setRunEvent( (unsigned long)beginRun, (unsigned long)beginLB );
299  IOVTime stop;
300  stop.setRunEvent ( (unsigned long)endRun, (unsigned long)endLB );
301  std::string key = "";
302 
303  return ( registerIOV( typeName,
304  key,key,
305  tag,
306  start,
307  stop) );
308 }

◆ 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 473 of file IOVRegistrationSvc.cxx.

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

◆ 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 1180 of file IOVRegistrationSvc.cxx.

1182  {
1183  // this routine was originally in IOVDbSvc, moved here as only client
1184  // Deals with address of form
1185  // <address_header service_type="256" clid="1238547719" /> POOLContainer_CondAttrListCollection][CLID=x
1186  // return header as part up to and including />, trailer as rest
1187 
1188  std::string::size_type p1=address.find(" />");
1189  if (p1!=std::string::npos) {
1190  address_header=address.substr(0,p1+3);
1191  address_data=address.substr(p1+4);
1192  return StatusCode::SUCCESS;
1193  } else {
1194  return StatusCode::FAILURE;
1195  }
1196 }

◆ timeToNano()

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

Definition at line 1156 of file IOVRegistrationSvc.cxx.

1157 {
1158  // convert time specified in seconds to ns used by COOL
1159  // use the magic value MAXEVENT to signal full range
1160  if (timesec==IOVTime::MAXEVENT) {
1161  return IOVTime::MAXTIMESTAMP;
1162  } else {
1163  return static_cast<uint64_t>(timesec)*1000000000;
1164  }
1165 }

◆ type()

const InterfaceID & IOVRegistrationSvc::type ( ) const
virtual

Service type.

Definition at line 101 of file IOVRegistrationSvc.cxx.

103 {
104  return IIOVRegistrationSvc::interfaceID();
105 }

Friends And Related Function Documentation

◆ SvcFactory< IOVRegistrationSvc >

friend class SvcFactory< IOVRegistrationSvc >
friend

Definition at line 141 of file IOVRegistrationSvc.h.

Member Data Documentation

◆ m_beginLB

UnsignedIntegerProperty IOVRegistrationSvc::m_beginLB
private

Definition at line 189 of file IOVRegistrationSvc.h.

◆ m_beginRun

UnsignedIntegerProperty IOVRegistrationSvc::m_beginRun
private

Definition at line 187 of file IOVRegistrationSvc.h.

◆ m_beginTime

UnsignedLongProperty IOVRegistrationSvc::m_beginTime
private

Definition at line 192 of file IOVRegistrationSvc.h.

◆ m_clidSvc

ServiceHandle<IClassIDSvc> IOVRegistrationSvc::m_clidSvc
private

Definition at line 210 of file IOVRegistrationSvc.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> IOVRegistrationSvc::m_detStore
private

Definition at line 208 of file IOVRegistrationSvc.h.

◆ m_endLB

UnsignedIntegerProperty IOVRegistrationSvc::m_endLB
private

Definition at line 190 of file IOVRegistrationSvc.h.

◆ m_endRun

UnsignedIntegerProperty IOVRegistrationSvc::m_endRun
private

Definition at line 188 of file IOVRegistrationSvc.h.

◆ m_endTime

UnsignedLongProperty IOVRegistrationSvc::m_endTime
private

Definition at line 193 of file IOVRegistrationSvc.h.

◆ m_forceGlobalIOV

BooleanProperty IOVRegistrationSvc::m_forceGlobalIOV
private

Definition at line 203 of file IOVRegistrationSvc.h.

◆ m_iov_db

ServiceHandle<IIOVCondDbSvc> IOVRegistrationSvc::m_iov_db
private

Definition at line 207 of file IOVRegistrationSvc.h.

◆ m_overrideName

std::vector<std::string> IOVRegistrationSvc::m_overrideName
private

Definition at line 204 of file IOVRegistrationSvc.h.

◆ m_overrideType

std::vector<std::string> IOVRegistrationSvc::m_overrideType
private

Definition at line 205 of file IOVRegistrationSvc.h.

◆ m_payloadTable

BooleanProperty IOVRegistrationSvc::m_payloadTable
private

Definition at line 202 of file IOVRegistrationSvc.h.

◆ m_persSvc

ServiceHandle<IAddressCreator> IOVRegistrationSvc::m_persSvc
private

Definition at line 209 of file IOVRegistrationSvc.h.

◆ m_recreateFolders

BooleanProperty IOVRegistrationSvc::m_recreateFolders
private

Definition at line 186 of file IOVRegistrationSvc.h.

◆ m_svFolder

BooleanProperty IOVRegistrationSvc::m_svFolder
private

Definition at line 201 of file IOVRegistrationSvc.h.

◆ m_tag

StringProperty IOVRegistrationSvc::m_tag
private

Definition at line 195 of file IOVRegistrationSvc.h.

◆ m_tagDescription

StringProperty IOVRegistrationSvc::m_tagDescription
private

Definition at line 197 of file IOVRegistrationSvc.h.

◆ m_timeStamp

BooleanProperty IOVRegistrationSvc::m_timeStamp
private

Definition at line 196 of file IOVRegistrationSvc.h.

◆ m_userTags

BooleanProperty IOVRegistrationSvc::m_userTags
private

Definition at line 199 of file IOVRegistrationSvc.h.

◆ m_userTagsUH

BooleanProperty IOVRegistrationSvc::m_userTagsUH
private

Definition at line 200 of file IOVRegistrationSvc.h.

◆ m_writeKeyInfo

BooleanProperty IOVRegistrationSvc::m_writeKeyInfo
private

Definition at line 198 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
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
CondAttrListCollection::end
const_iterator end() const
Definition: CondAttrListCollection.h:315
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IOVRegistrationSvc::m_beginLB
UnsignedIntegerProperty m_beginLB
Definition: IOVRegistrationSvc.h:189
IOVRange
Validity Range object. Holds two IOVTimes (start and stop)
Definition: IOVRange.h:30
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
CondAttrListCollection::iov_end
iov_const_iterator iov_end() const
Definition: CondAttrListCollection.h:343
IOVTime::MAXRUN
static constexpr uint32_t MAXRUN
Definition: IOVTime.h:48
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
initialize
void initialize()
Definition: run_EoverP.cxx:894
IOVRegistrationSvc::m_svFolder
BooleanProperty m_svFolder
Definition: IOVRegistrationSvc.h:201
IOVRegistrationSvc::m_tag
StringProperty m_tag
Definition: IOVRegistrationSvc.h:195
CaloCondBlobAlgs_fillNoiseFromASCII.db
db
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:43
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
python.CreateTierZeroArgdict.parname
parname
Definition: CreateTierZeroArgdict.py:194
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
skel.it
it
Definition: skel.GENtoEVGEN.py:396
IOVRegistrationSvc::m_writeKeyInfo
BooleanProperty m_writeKeyInfo
Definition: IOVRegistrationSvc.h:198
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
IOVRegistrationSvc::m_userTags
BooleanProperty m_userTags
Definition: IOVRegistrationSvc.h:199
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:473
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
xAOD::identifier
identifier
Definition: UncalibratedMeasurement_v1.cxx:15
IOVRegistrationSvc::m_endRun
UnsignedIntegerProperty m_endRun
Definition: IOVRegistrationSvc.h:188
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:92
IOVRegistrationSvc::m_endLB
UnsignedIntegerProperty m_endLB
Definition: IOVRegistrationSvc.h:190
CondAttrListCollection::iov_const_iterator
ChanIOVMap::const_iterator iov_const_iterator
Definition: CondAttrListCollection.h:66
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
IOVTime::MINRUN
static constexpr uint32_t MINRUN
Definition: IOVTime.h:44
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:1180
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
IOVRegistrationSvc::m_forceGlobalIOV
BooleanProperty m_forceGlobalIOV
Definition: IOVRegistrationSvc.h:203
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
checkCoolLatestUpdate.chanNum
chanNum
Definition: checkCoolLatestUpdate.py:27
IOVRegistrationSvc::m_iov_db
ServiceHandle< IIOVCondDbSvc > m_iov_db
Definition: IOVRegistrationSvc.h:207
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:496
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
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:1115
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
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
IOVRegistrationSvc::m_overrideType
std::vector< std::string > m_overrideType
Definition: IOVRegistrationSvc.h:205
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
CondAttrListCollection::ChanNum
unsigned int ChanNum
Definition: CondAttrListCollection.h:55
IOVRegistrationSvc::m_persSvc
ServiceHandle< IAddressCreator > m_persSvc
Definition: IOVRegistrationSvc.h:209
IOVRegistrationSvc::m_recreateFolders
BooleanProperty m_recreateFolders
Definition: IOVRegistrationSvc.h:186
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
IOVRegistrationSvc::m_endTime
UnsignedLongProperty m_endTime
Definition: IOVRegistrationSvc.h:193
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:20
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
EventContainers::Mode
Mode
Definition: IdentifiableContainerBase.h:13
RTTAlgmain.address
address
Definition: RTTAlgmain.py:55
IOVTime::MINEVENT
static constexpr uint32_t MINEVENT
Definition: IOVTime.h:50
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:210
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:1167
IOVRegistrationSvc::type
virtual const InterfaceID & type() const
Service type.
Definition: IOVRegistrationSvc.cxx:101
get_generator_info.version
version
Definition: get_generator_info.py:33
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::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:189
DeMoScan.first
bool first
Definition: DeMoScan.py:536
IOVRegistrationSvc::m_payloadTable
BooleanProperty m_payloadTable
Definition: IOVRegistrationSvc.h:202
DEBUG
#define DEBUG
Definition: page_access.h:11
IOVRegistrationSvc::m_userTagsUH
BooleanProperty m_userTagsUH
Definition: IOVRegistrationSvc.h:200
IOVRegistrationSvc::m_beginTime
UnsignedLongProperty m_beginTime
Definition: IOVRegistrationSvc.h:192
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:56
ReadCalibFromCool.typeName
typeName
Definition: ReadCalibFromCool.py:477
IOVRegistrationSvc::m_timeStamp
BooleanProperty m_timeStamp
Definition: IOVRegistrationSvc.h:196
IOVTime::MINTIMESTAMP
static constexpr uint64_t MINTIMESTAMP
Definition: IOVTime.h:56
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
IOVRegistrationSvc::m_overrideName
std::vector< std::string > m_overrideName
Definition: IOVRegistrationSvc.h:204
CondAttrListCollection::chanIOVPair
iov_const_iterator chanIOVPair(ChanNum chanNum) const
Access to Chan/IOV pairs via channel number: returns map iterator.
Definition: CondAttrListCollection.h:330
SG::DataProxy
Definition: DataProxy.h:44
IOVRegistrationSvc::m_beginRun
UnsignedIntegerProperty m_beginRun
Definition: IOVRegistrationSvc.h:187
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
IOVRegistrationSvc::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: IOVRegistrationSvc.h:208
IOVRegistrationSvc::timeToNano
uint64_t timeToNano(const unsigned long int timesec) const
Definition: IOVRegistrationSvc.cxx:1156
lumiFormat.endTime
endTime
Definition: lumiFormat.py:100
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
IOVRegistrationSvc::m_tagDescription
StringProperty m_tagDescription
Definition: IOVRegistrationSvc.h:197
Generated on Thu Nov 7 2024 21:46:00 for ATLAS Offline Software by   doxygen 1.8.18