ATLAS Offline Software
CaloCondTools.py
Go to the documentation of this file.
1 #!/bin/env python
2 
3 # Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
4 # CaloCondTools.py
5 # Nils Gollub <nils.gollub@cern.ch>, 2007-11-23
6 # Carlos Solans <carlos.solans@cern.ch>, 2012-11-07
7 """
8 Python helper module for managing COOL DB connections and CaloCondBlobs.
9 """
10 
11 import os
12 import cppyy
13 from PyCool import cool
14 import time, re
15 g = cppyy.gbl
16 
17 
18 #=== get a logger
19 from CaloCondBlobAlgs.CaloCondLogger import CaloCondLogger, getLogger
20 log = getLogger("CaloCondTools")
21 
22 #=== useful constants
23 MINRUN = 0
24 MINLBK = 0
25 MAXRUN = cool.Int32Max
26 MAXLBK = cool.UInt32Max
27 UNIX2COOL = 1000000000
28 UNIXTMAX = cool.Int32Max
29 
30 #
31 #______________________________________________________________________
33  """
34  Returns the common Calo prefix used for all COOL folders
35  """
36  return "/CALO/"
37 
38 #
39 #______________________________________________________________________
41  """
42  Returns the run-lumi type folder description needed to read back the folder content
43  as a CondAttrListCollection in Athena.
44  """
45  desc ='<timeStamp>run-lumi</timeStamp>'
46  desc+='<addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader>'
47  desc+='<typeName>CondAttrListCollection</typeName>'
48  return desc
49 
50 #
51 #______________________________________________________________________
52 def getAthenaFolderType(folderDescr):
53  type = re.compile(".*<timeStamp>(.*)</timeStamp>.*").search(folderDescr)
54  if not type:
55  raise Exception("No folder type info found in \'%s\'" % folderDescr)
56  return type.groups()[0]
57 
58 #
59 #______________________________________________________________________
60 def openDb(db, instance, mode="READONLY", schema="COOLOFL_CALO", sqlfn="caloSqlite.db"):
61  """
62  Opens a COOL db connection.
63  - db: The DB type. The following names are recognized:
64  * SQLITE: Opens file mentioned in sqlfn parameter
65  * ORACLE or FRONTIER: Opens ORACLE DB, forces READONLY
66  - instance: One of valid instances - CONDBR2 OFLP200 COMP200 CMCP200
67  - mode: Can be READONLY (default), RECREATE or UPDATE
68  - schema: One of valid schemas - COOLONL_CALO COOLOFL_CALO COOLONL_LAR COOLOFL_LAR COOLONL_TILE COOLOFL_TILE
69  - sqlfn: Name of sqlite file if db is SQLITE
70  """
71  #=== check for valid db names
72  if db is not None:
73  validDb = ["SQLITE", "ORACLE", "FRONTIER"]
74  if db not in validDb:
75  raise Exception( "DB not valid: %s, valid DBs are: %s" % (db,validDb) )
76  elif db == "ORACLE" or db == "FRONTIER":
77  mode = "READONLY"
78 
79  #=== check for valid instance names
80  validInstance = ["COMP200", "CONDBR2", "CMCP200", "OFLP200"]
81  if instance not in validInstance:
82  raise Exception( "Instance not valid: %s, valid instance are: %s" % (instance,validInstance) )
83 
84  #=== check for valid schema names
85  validSchema = ["COOLONL_CALO","COOLOFL_CALO","COOLONL_LAR","COOLOFL_LAR","COOLONL_TILE","COOLOFL_TILE"]
86  if schema not in validSchema:
87  raise Exception( "Schema not valid: %s, valid schemas are: %s" % (schema,validSchema) )
88 
89  #=== construct connection string
90  connStr = ""
91  if db=='SQLITE':
92  if mode=="READONLY" and not os.path.exists(sqlfn):
93  raise Exception( "Sqlite file %s does not exist" % (sqlfn) )
94  if (mode=="RECREATE" or mode=="UPDATE") and not os.path.exists(os.path.dirname(sqlfn)):
95  dirn=os.path.dirname(sqlfn)
96  if dirn:
97  os.makedirs(dirn)
98  connStr="sqlite://X;schema=%s;dbname=%s" % (sqlfn,instance)
99  elif db=='FRONTIER':
100  connStr='frontier://ATLF/()/;schema=ATLAS_%s;dbname=%s' % (schema,instance)
101  elif db=='ORACLE':
102  connStr='oracle://%s;schema=ATLAS_%s;dbname=%s' % ('ATLAS_COOLPROD',schema,instance)
103  else:
104  connStr=schema+'/'+instance
105 
106  return openDbConn(connStr, mode)
107 
108 #
109 #______________________________________________________________________
110 def openDbConn(connStr, mode="READONLY"):
111  """
112  Opens a COOL db connection.
113  - connStr: The DB connection string
114  - mode: Can be READONLY (default), RECREATE or UPDATE
115  or ORACLE or FRONTIER if connStr is only short name of the database
116  """
117 
118  #=== split the name into schema and dbinstance
119  splitname=connStr.split('/')
120  if (len(splitname)!=2): # string connection ready to be used as it is
121  connStr_new=connStr
122  else: # construct connection string
123  schema=splitname[0]
124  instance=splitname[1]
125  if mode=="ORACLE":
126  connStr_new='oracle://%s;schema=ATLAS_%s;dbname=%s' % ('ATLAS_COOLPROD',schema,instance)
127  else:
128  connStr_new='frontier://ATLF/()/;schema=ATLAS_%s;dbname=%s' % (schema,instance)
129 
130  #=== get dbSvc and print header info
131  dbSvc = cool.DatabaseSvcFactory.databaseService()
132  log.info( "---------------------------------------------------------------------------------" )
133  log.info( "-------------------------- CaloCondTools.openDbConn -----------------------------" )
134  log.info( "- using COOL version %s", dbSvc.serviceVersion() )
135  log.info( "- opening CaloDb: %s",connStr_new )
136  log.info( "- mode: %s", mode )
137  log.info( "---------------------------------------------------------------------------------" )
138 
139  #=== action depends on mode
140  if mode in ["READONLY","ORACLE","FRONTIER","",None]:
141  #=== open read only
142  try:
143  db=dbSvc.openDatabase(connStr_new,True)
144  except Exception as e:
145  log.debug( e )
146  log.critical("Could not connect to %s" % connStr_new )
147  return None
148  return db
149  elif mode=="RECREATE":
150  #=== recreating database
151  dbSvc.dropDatabase(connStr_new)
152  try:
153  db = dbSvc.createDatabase(connStr_new)
154  except Exception as e:
155  log.debug( e )
156  log.critical( "Could not create database, giving up..." )
157  return None
158  return db
159  elif mode=="UPDATE":
160  #=== update database
161  try:
162  db=dbSvc.openDatabase(connStr_new,False)
163  except Exception as e:
164  log.debug( e )
165  log.warning( "Could not connect to \'%s\', trying to create it....", connStr_new )
166  try:
167  db=dbSvc.createDatabase(connStr_new)
168  except Exception as e:
169  log.debug( e )
170  log.critical( "Could not create database, giving up..." )
171  return None
172  return db
173  else:
174  log.error("Mode \"%s\" not recognized", mode )
175  return None
176 
177 #
178 #______________________________________________________________________
179 def iovFromRunLumi(runNum, lbkNum):
180  """
181  Returns COOL timeStamp build from run and lumi block numbers
182  """
183  return (int(runNum)<<32) + int(lbkNum)
184 
185 #
186 #______________________________________________________________________
187 def decodeTimeString(timeString):
188  """
189  Returns UNIX time stamp given an input time string
190  """
191  return int(time.mktime(time.strptime(timeString,"%Y-%m-%d %H:%M:%S")))
192 
193 #
194 #______________________________________________________________________
195 def getCoolValidityKey(pointInTime, isSince=True):
196  """
197  The interpretation of pointInTime depends on their type:
198  - tuple(int,int) : run and lbk number
199  - integer : Values are interpreted as unix time stamps
200  - string : time stamp of format 'yyyy-mm-dd hh:mm:ss'
201  """
202 
203  validityKey = None
204 
205  #=== string: convert to unix time and treat as latter
206  if isinstance(pointInTime, str):
207  pointInTime = decodeTimeString(pointInTime)
208 
209  #=== integer: unix time stamp
210  if isinstance(pointInTime, int):
211  if pointInTime >=0:
212  validityKey = pointInTime * UNIX2COOL
213  else:
214  if isSince:
215  validityKey = int(time.time()) * UNIX2COOL
216  else :
217  validityKey = cool.ValidityKeyMax
218  #=== run-lumi tuple
219  elif isinstance(pointInTime, tuple):
220  validityKey = iovFromRunLumi(pointInTime[0],pointInTime[1])
221  #=== catch other types
222  else:
223  raise Exception("Unrecognized pointInTime type=%s" % type(pointInTime))
224  return cool.ValidityKey(validityKey)
225 
226 #
227 #______________________________________________________________________
228 def getCellHash(detectorId,part,module,sample,tower):
229  """
230  Returns cell subHash given partition,module,sample, and tower (TILE only)
231  """
232  if detectorId != 48:
233  raise Exception('getCellHash only available for TileCells.')
234  section = 0 # 1=LB* 2=EB* 3=ITC
235  side = 0 # 1=A-side -1=C-side
236  if part == 1 or part == 2:
237  section = 1
238  elif part == 3 or part == 4:
239  if sample == 3 or (sample==1 and tower==9) or (sample==2 and tower==8): # Gap and ITC
240  section = 3
241  else:
242  section = 2
243  if part%2 ==0:
244  side = -1
245  else:
246  side = 1
247  if section==0 or side==0 or module>63 or sample>3 or tower>15:
248  raise Exception('Non-physical cell specification')
249 
250  # hash array for mod0 of entire TileCal. Use to determine cell hash for any cell
251  hash = [0, 1, -1, -1, 2, 3, -1, -1, 4, 5, 6, -1, 7, 8, -1, -1, 9, 10, 11, -1, 12, 13, -1, -1, 14, 15, 16, -1, 17, 18, -1, -1, 19, 20, 4416, -1, 21, 4417, -1, -1, -1, 2880, 2881, 4418, 2882, 2883, -1, 4419, 2884, 2885, 2886, -1, 2887, 2888, -1, 4420, 2889, 2890, -1, -1, 2891, -1, -1, 4421, 1408, 1409, 1410, -1, 1411, 1412, -1, -1, 1413, 1414, 1415, -1, 1416, 1417, -1, -1, 1418, 1419, 1420, -1, 1421, 1422, -1, -1, 1423, 1424, 1425, -1, 1426, 1427, -1, -1, 1428, 1429, 4800, -1, 1430, 4801, -1, -1, -1, 3648, 3649, 4802, 3650, 3651, -1, 4803, 3652, 3653, 3654, -1, 3655, 3656, -1, 4804, 3657, 3658, -1, -1, 3659, -1, -1, 4805]
252 
253  # Section specific offset to be added to cell hash for module different from 0
254  # [LBC,LBA,EBC,EBA,ITC-C,ITC-A]
255  modOffset = [22,23,12,12,6,6]
256  if side==1:
257  sideOffset=1
258  else:
259  sideOffset=0
260 
261  return hash[sideOffset*16*4+tower*4+sample]+modOffset[sideOffset+2*(section-1)]*module
262 
263 #======================================================================
264 #===
265 #=== CaloBlobReader
266 #===
267 #======================================================================
268 
269 #
270 #______________________________________________________________________
271 class CaloBlobReader(CaloCondLogger):
272  """
273  CaloBlobReader is a helper class, managing the details of COOL interactions
274  """
275 
276  #____________________________________________________________________
277  def __init__(self, db, folder, tag=""):
278  """
279  Input:
280  - db : db should be an open database connection
281  - folder: full folder path
282  - tag : The folder tag, e.g. \"000-00\"
283  """
284  #=== initialize base class
285  CaloCondLogger.__init__(self,"CaloBlobReader")
286 
287  #=== try to open db
288  try:
289  self.__db = db
290  self.__folder = self.__db.getFolder(folder)
291  except Exception as e:
292  self.log().critical( e )
293  raise
294 
295  #=== determine if "run-lumi" or "time" folder
296  validFolderTypes = ("run-lumi","time")
297  folderDescr = self.__folder.description()
298  self.__folderType = getAthenaFolderType(folderDescr)
299  if self.__folderType not in validFolderTypes:
300  raise Exception("Invalid folder type found: \'%s\'" % self.__folderType)
301 
302  #=== use camelized full folder path only if tag is given
303  self.__tag = tag
304 
305  #=== initialize dictionary to keep reference to DB object
306  #=== and timestamp, so they do not go out of scope
307  self.__objDict = {}
308 
309  #____________________________________________________________________
310  def getCells(self, systemId, pointInTime):
311  """
312  Returns a CaloCondBlob object for the given system.
313  """
314 
315  validityKey = getCoolValidityKey(pointInTime)
316  self.log().debug("Validity key is %s", validityKey)
317  try:
318  #=== Have we retrieved data previously?
319  key = (systemId,validityKey)
320  obj = self.__objDict.get(key)
321  #=== ... if not, get it from DB
322  if not obj:
323  channelId = cool.ChannelId(systemId)
324  obj = self.__folder.findObject(validityKey, channelId, self.__tag)
325  self.log().debug("Fetching from DB: %s", obj)
326  blob = obj.payload()[0]
327  self.log().debug("blob size: %d", blob.size())
328  #=== store object in dictionary
329  self.__objDict[key] = obj
330  #=== get blob
331  blob = obj.payload()[0]
332  self.log().debug("blob size: %d", blob.size())
333 
334  #=== create CaloCondBlob object
335  flt = g.CaloCondBlobFlt.getInstance(blob)
336  return flt
337  except Exception as e:
338  self.log().error("Fetching of systemId=%i failed with exception %s",systemId,e)
339  return None
340 
341 
342  #____________________________________________________________________
344  """
345  Returns true if MultiVersion folder is connected
346  """
347  if self.__folder.versioningMode()==cool.FolderVersioning.MULTI_VERSION:
348  return True
349  else:
350  return False
351 
352 
353 #======================================================================
354 #===
355 #=== CaloBlobWriter
356 #===
357 #======================================================================
358 
359 #
360 #______________________________________________________________________
361 class CaloBlobWriter(CaloCondLogger):
362  """
363  Helper class that enables writing to Calo DB
364  """
365 
366  #____________________________________________________________________
367  def __init__(self, db, folderPath, caloBlobType=None,
368  isMultiVersionFolder=True, isRunLumiTimeStamp=True):
369  """
370  Input:
371  - db : db should be an open database connection
372  - folderPath: full folder path to create or update
373  """
374 
375  #=== initialize base class
376  CaloCondLogger.__init__(self,"CaloBlobWriter")
377 
378  #=== store db
379  self.__db = db
380 
381  #=== determine folder mode
382  folderMode = cool.FolderVersioning.MULTI_VERSION
383  if not isMultiVersionFolder:
384  folderMode = cool.FolderVersioning.SINGLE_VERSION
385 
386  #=== determine folder description
387  folderDescr = getAthenaFolderDescr()
388 
389  #=== access folder in db
390  try:
391  #=== create folder if it does not exist
392  if self.__db.existsFolder(folderPath):
393  self.__folder = self.__db.getFolder(folderPath)
394  #=== check folder mode
395  modeInCool = self.__folder.versioningMode()
396  if modeInCool!=folderMode:
397  str = "Incompatible folder mode detected, COOL folder has type "
398  if modeInCool==cool.FolderVersioning.MULTI_VERSION:
399  str += "MULTI"
400  else:
401  str += "SINGLE"
402  raise Exception(str)
403  else:
404  #=== create folder if it does not exist
405  payloadSpec = cool.RecordSpecification()
406  payloadSpec.extend( 'CaloCondBlob16M', cool.StorageType.Blob16M )
407  folderSpec = cool.FolderSpecification(folderMode, payloadSpec)
408  self.__folder = db.createFolder(folderPath, folderSpec, folderDescr, True)
409  except Exception as e:
410  self.log().critical( e )
411  raise
412 
413  #=== initialize channel dictionaries
414  self.__chanDictRecord = {} # <int, cool.Record >
415  self.__chanDictCells = {} # <int, CaloCondBlobFlt>
416 
417  #____________________________________________________________________
418  def register(self, since=(MINRUN,MINLBK), until=(MAXRUN,MAXLBK), tag=""):
419  """
420  Registers the folder in the database.
421  - since: lower limit of IOV
422  - until: upper limit of IOV
423  - tag : The cool folder tag to write to
424 
425  The interpretation of the 'since' and 'until' inputs depends on their type:
426  - tuple(int,int) : run and lbk number
427  - integer : Values are interpreted as unix time stamps
428  If since<0, current time is assumed
429  If until<0, infinity is assumed
430  - string : time stamp of format 'yyyy-mm-dd hh:mm:ss'
431  """
432 
433  #=== check for inconsistent input
434  if type(since)!=type(until):
435  raise Exception("Inconsistent types: since=%s, until=%s" % (type(since),type(until)))
436 
437  #=== write to user tag only if multiversion mode
438  userTagOnly = True
439  if self.__folder.versioningMode()==cool.FolderVersioning.SINGLE_VERSION:
440  userTagOnly = False
441  #=== no folder Tag allowed for singleversion
442  if tag!="":
443  self.log().warning( "Trying to store with tag \"%s\" to SINGLE_VERSION folder", tag )
444  self.log().warning( "... resetting tag to \"\"!" )
445  tag=""
446 
447  #=== get IOV limits
448  sinceCool = getCoolValidityKey(since, True )
449  untilCool = getCoolValidityKey(until, False)
450  if untilCool <= sinceCool:
451  raise Exception("Until(%i) <= Since(%i)" % (untilCool,sinceCool))
452 
453  #=== build IOV string
454  iovString = ""
455  if isinstance(since, tuple):
456  iovString = "[%i,%i] - [%i,%i]" % (since[0],since[1],until[0],until[1])
457  else:
458  sinceInfo = time.localtime( sinceCool//UNIX2COOL )
459  untilInfo = time.localtime(min(UNIXTMAX, (untilCool//UNIX2COOL)))
460  untilStr = "<infinity>"
461  if untilCool<cool.ValidityKeyMax:
462  untilStr = time.asctime(untilInfo)
463  if (untilCool//UNIX2COOL)>UNIXTMAX:
464  untilStr = " > "+untilStr
465  iovString = "[%s] - [%s]" % (time.asctime(sinceInfo), untilStr)
466 
467  #=== build tag
468  folderTag=tag
469 
470  #=== print info
471  self.log().info( "Registering folder %s with tag \"%s\"", self.__folder.fullPath(),folderTag)
472  self.log().info( "... with IOV : %s", iovString )
473  #self.log().info( "... with comment field: \"%s\"", self.__chanDictDrawer[48].getComment() )
474 
475  #=== register all channels by increasing channel number
476  chanList = sorted(self.__chanDictRecord.keys())
477  for chanNum in chanList:
478  data = self.__chanDictRecord[chanNum]
479  strout = "cool channel=%4i" % chanNum
480  self.log().debug("Registering %s %s", (strout, data))
481  channelId = cool.ChannelId(chanNum)
482  self.__folder.storeObject(sinceCool, untilCool, data, channelId, folderTag, userTagOnly)
483 
484  #____________________________________________________________________
485  def getCells(self, systemId):
486  """
487  Returns a CaloCondBlob object of given system Id.
488  """
489 
490  #try:
491  chanNum = cool.ChannelId(systemId)
492  flt = self.__chanDictCells.get(chanNum,None)
493  #=== ... if not, get it from DB
494  if not flt:
495  #=== create new blob
496  spec = self.__folder.payloadSpecification()
497  data = cool.Record( spec )
498  self.__chanDictRecord[chanNum] = data
499  for key in data:
500  blob = data[key]
501  flt = g.CaloCondBlobFlt.getInstance(blob)
502 
503  self.__chanDictCells[chanNum] = flt
504  return flt
505 
506  #except Exception as e:
507  # self.log().critical( e )
508  # return None
509 
510  #____________________________________________________________________
511  #def setComment(self, author, comment):
512  # """
513  # Sets a general comment in the comment channel.
514  # """
515  # try:
516  # chanNum = TileCalibUtils.getCommentChannel()
517  # data = self.__chanDictRecord.get(chanNum)
518  # if not data:
519  # spec = self.__folder.payloadSpecification()
520  # data = cool.Record( spec )
521  # self.__chanDictRecord[chanNum] = data
522  # blob = data['TileCalibBlob']
523  # cmt = TileCalibDrawerCmt.getInstance(blob,author,comment)
524  # except Exception as e:
525  # self.log().critical( e )
526 
527 
528 
529  #____________________________________________________________________
530  def zeroBlob(self, systemId):
531  """
532  Resets blob size to zero
533  """
534  try:
535  chanNum = cool.ChannelId(systemId)
536  data = self.__chanDictRecord.get(systemId)
537  if not data:
538  spec = self.__folder.payloadSpecification()
539  data = cool.Record( spec )
540  self.__chanDictRecord[chanNum] = data
541  blob = data['CaloCondBlob16M']
542  blob.resize(0)
543  except Exception as e:
544  self.log().critical( e )
545  return None
546 
python.CaloCondTools.getCellHash
def getCellHash(detectorId, part, module, sample, tower)
Definition: CaloCondTools.py:228
grepfile.info
info
Definition: grepfile.py:38
python.CaloCondTools.getAthenaFolderType
def getAthenaFolderType(folderDescr)
Definition: CaloCondTools.py:52
python.CaloCondTools.CaloBlobWriter.__folder
__folder
Definition: CaloCondTools.py:392
python.CaloCondTools.decodeTimeString
def decodeTimeString(timeString)
Definition: CaloCondTools.py:187
python.CaloCondTools.CaloBlobWriter.__chanDictRecord
__chanDictRecord
Definition: CaloCondTools.py:413
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
python.CaloCondTools.getCoolValidityKey
def getCoolValidityKey(pointInTime, isSince=True)
Definition: CaloCondTools.py:195
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
python.CaloCondTools.CaloBlobWriter.__db
__db
Definition: CaloCondTools.py:378
CscCalibQuery.fullPath
string fullPath
Definition: CscCalibQuery.py:360
python.CaloCondTools.getAthenaFolderDescr
def getAthenaFolderDescr()
Definition: CaloCondTools.py:40
python.CaloCondTools.CaloBlobReader
Definition: CaloCondTools.py:271
search
void search(TDirectory *td, const std::string &s, std::string cwd, node *n)
recursive directory search for TH1 and TH2 and TProfiles
Definition: hcg.cxx:738
python.CaloCondTools.CaloBlobWriter.getCells
def getCells(self, systemId)
Definition: CaloCondTools.py:485
python.CaloCondTools.CaloBlobReader.folderIsMultiVersion
def folderIsMultiVersion(self)
Definition: CaloCondTools.py:343
python.CaloCondTools.CaloBlobReader.__folderType
__folderType
Definition: CaloCondTools.py:298
python.CaloCondTools.CaloBlobReader.__objDict
__objDict
Definition: CaloCondTools.py:307
python.CaloCondTools.CaloBlobReader.__db
__db
Definition: CaloCondTools.py:289
python.CaloCondTools.CaloBlobReader.__folder
__folder
Definition: CaloCondTools.py:290
python.CaloCondTools.CaloBlobWriter.zeroBlob
def zeroBlob(self, systemId)
Definition: CaloCondTools.py:530
DerivationFramework::TriggerMatchingUtils::sorted
std::vector< typename T::value_type > sorted(T begin, T end)
Helper function to create a sorted vector from an unsorted one.
python.CaloCondTools.CaloBlobWriter.__init__
def __init__(self, db, folderPath, caloBlobType=None, isMultiVersionFolder=True, isRunLumiTimeStamp=True)
Definition: CaloCondTools.py:367
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
python.CaloCondTools.CaloBlobReader.__init__
def __init__(self, db, folder, tag="")
Definition: CaloCondTools.py:277
python.CaloCondTools.openDbConn
def openDbConn(connStr, mode="READONLY")
Definition: CaloCondTools.py:110
python.CaloCondTools.openDb
def openDb(db, instance, mode="READONLY", schema="COOLOFL_CALO", sqlfn="caloSqlite.db")
Definition: CaloCondTools.py:60
python.CaloCondTools.CaloBlobReader.getCells
def getCells(self, systemId, pointInTime)
Definition: CaloCondTools.py:310
python.CaloCondTools.CaloBlobWriter.__chanDictCells
__chanDictCells
Definition: CaloCondTools.py:414
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
python.CaloCondTools.getCaloPrefix
def getCaloPrefix()
Definition: CaloCondTools.py:32
python.CaloCondTools.CaloBlobWriter
Definition: CaloCondTools.py:361
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
python.CaloCondTools.CaloBlobReader.__tag
__tag
Definition: CaloCondTools.py:303
python.CaloCondTools.CaloBlobWriter.register
def register(self, since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK), tag="")
Definition: CaloCondTools.py:418
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
error
Definition: IImpactPoint3dEstimator.h:70
python.CaloCondTools.iovFromRunLumi
def iovFromRunLumi(runNum, lbkNum)
Definition: CaloCondTools.py:179
python.CaloCondLogger.getLogger
def getLogger(name="CaloCond")
Definition: CaloCondLogger.py:16
description
std::string description
glabal timer - how long have I taken so far?
Definition: hcg.cxx:88