def __init__(self, poolfile, **args):
"""An AOD file pointer (not a string) must be given as argument"""
self.__dict__.__setitem__("_TriggerConfigARA__curConf",
_TrigConfHolder())
self.__currentIOV = {}
self.verbose = False
if 'verbose' in args: self.verbose = args['verbose']
plcClass = cppyy.makeClass("IOVPayloadContainer")
plcClass.iter = _iter
tiClass = cppyy.makeClass("TrigConf::TriggerItem")
tiClass.__str__ = lambda x: "%s (ctpid %i), ps %g" % (x.name(),
x.ctpId(), x.ps)
chClass = cppyy.makeClass("TrigConf::HLTChain")
chClass.__str__ = _chPrint
ROOT.IOVTime.__str__ = lambda x: "%i/%i" % (x.run(), x.event())
ROOT.IOVTime.__lt__ = lambda s, o: s.run() < o.run() or s.run(
) == o.run() and s.event() < o.event()
ROOT.IOVTime.__eq__ = lambda s, o: s.run() == o.run() and s.event(
) == o.event()
ROOT.IOVTime.__le__ = lambda s, o: s < o or s == o
ROOT.IOVRange.__str__ = lambda x: "%s - %s" % (x.start(), x.stop())
ROOT.IOVRange.isInRange = lambda x, e: x.start() <= e and e < x.stop()
print("Opening file(s) and creating transient metadata ...")
if type(poolfile) == list:
self._collection = ROOT.AthenaROOTAccess.TChainROOTAccess(
'MetaData')
for file in poolfile:
self._collection.Add(file)
self.mdt = AthenaROOTAccess.transientTree.makeTree(
self._collection,
persTreeName='MetaData',
dhTreeName='MetaDataHdr',
dhfilt=_elemFilter)
else:
treeNames = [k.GetName() for k in poolfile.GetListOfKeys()]
if "MetaDataHdrDataHeader" in treeNames:
dhTreeName = 'MetaDataHdrDataHeader' # old style
else:
dhTreeName = 'MetaDataHdr'
self.mdt = AthenaROOTAccess.transientTree.makeTree(
poolfile,
persTreeName='MetaData',
dhTreeName=dhTreeName,
dhfilt=_elemFilter)
for key in self.__class__.__keysInUpdateOrder:
if not hasattr(self.mdt, self.__class__.__folderName[key]):
print("No key %s in file %s, use checkFile.py to verify" %
(self.__class__.__folderName[key], poolfile))
sys.exit(0)
def deserialize_string(lwords):
"""Wrapper for the C++ StringSerializer"""
v = cppyy.makeClass('std::vector<unsigned int>')()
s = cppyy.makeClass('std::string')()
v.reserve(len(lwords))
for w in lwords:
v.push_back(w)
stringSerializer.deserialize(v, s)
return str(s)
def BadChan_GetCoolChannelNameFromHWIdentifier(self,sHWid):
""" Get channel name from HW identifier (only for text menu purpose)"""
self.class_LArBadChannelState=cppyy.makeClass('LArBadChannelState')
inst_larBadChannelState=self.class_LArBadChannelState()
sChannelName=""
if self.onlineID.isEMBchannel(sHWid):
if self.onlineID.pos_neg(sHWid)==1:
iEnumChannel=inst_larBadChannelState.EMBA
else:
iEnumChannel=inst_larBadChannelState.EMBC
if self.onlineID.isEMECchannel(sHWid):
if self.onlineID.pos_neg(sHWid)==1:
iEnumChannel=inst_larBadChannelState.EMECA
else:
iEnumChannel=inst_larBadChannelState.EMECC
if self.onlineID.isHECchannel(sHWid):
if self.onlineID.pos_neg(sHWid)==1:
iEnumChannel=inst_larBadChannelState.HECA
else:
iEnumChannel=inst_larBadChannelState.HECC
if self.onlineID.isFCALchannel(sHWid):
if self.onlineID.pos_neg(sHWid)==1:
iEnumChannel=inst_larBadChannelState.FCALA
else:
iEnumChannel=inst_larBadChannelState.FCALC
sChannelName=inst_larBadChannelState.coolChannelName(iEnumChannel)+" ("+str(iEnumChannel)+")"
return sChannelName
def getMultiCondContainer(self, channels, attrListColl, iovs):
# Args:
# channels - list of channels from COOL
# attrListColl - collection of AttributeLists with string address from COOL for each channel
# iovs - list of IOVs for each channel
# cont - the LArConditionsContainer object
# Print out channels and IOV
print("Channels, IOV, and string addresses")
i = 0
for chan in channels:
iov = iovs[i]
print("added chan/iov: ", chan, iov.iovPrint())
i += 1
# print out collection
#attrListColl.dump()
# Must set dummy string address to include type name for
# AthenaPoolCnvSvc statistics gathering
strAddress = self.header
# Get IOpaqueAddress
print("Create IOpaqueAddress pointer")
ioa = PyLCGDict.libPyROOT.MakeNullPointer('GenericAddress')
# Get DataBucketBase pointer
print("Create DataBucketBase pointer")
dbb = PyLCGDict.libPyROOT.MakeNullPointer('DataBucketBase')
# Create IOA from string address
print("Create IOpaqueAddress for address list")
sc = self.iaddr.createAddress(0, 0, strAddress, ioa)
print("Status code: ", sc)
# Create CondAttrListCollAddress and add in attribute list
CondAttrListCollAddress = PyLCGDict.makeClass(
'CondAttrListCollAddress')
collAddr = CondAttrListCollAddress(ioa)
collAddr.setAttrListColl(attrListColl)
# Read in object as DataObject (or DatabucketBase)
print("Retrieve data object for IOA")
sc = self.icnv.createObj(collAddr, dbb)
print("Status code: ", sc)
if sc.isFailure(): raise RuntimeError("Cannot read object")
# Cast to correct type and return it
print("cast data object to correct type: ", self.typeName)
result = PyLCGDict.libPyROOT.MakeNullPointer(self.type)
self.dbCast.castObject(self.typeName, dbb, result)
# Reset iterator to allow a new type - bug in pyroot
#self.pyroot_typedef_bug_workaround()
return result
def setDescription(self, descr):
self.descr = descr
# extract type name and type
decoder = DescriptionDecoder(descr)
self.typeName = decoder.extract('<typeName>', '</typeName>')
self.type = PyLCGDict.makeClass(self.typeName)
# extract the address header
self.header = decoder.extract('<addrHeader>', '</addrHeader>')
self.header += 'POOLContainer_CondAttrListCollection][CLID=x'
print("Type name, type, header ", self.typeName, self.type,
self.header)
def __init__(self, theApp):
# PersistencySvc
pers = theApp.service('EventPersistencySvc')
# PersistencySvc via its IConverter interface
iConverter = InterfaceRDS('IConverter')
self.icnv = iConverter.cast(pers)
# PersistencySvc via its IAddressCreator interface
iAddrCreator = InterfaceRDS('IAddressCreator')
self.iaddr = iAddrCreator.cast(pers)
# Create instance of cast object
self.dbCast = PyLCGDict.makeClass('DataBucketCast')
def __init__(self, t):
# t is either the class name or the class itself
if type(t) is str:
self.typeName = t
t = cppyy.makeClass(t)
else:
self.typeName = t.type.__name__
# Save type
self.type = t
# Add on iterators for the different containers
self.type.conditionsIter = conditionsIter
self.type.correctionsIter = correctionsIter
self.type.coolChannelIter = coolChannelIter
self.type.coolIOVIter = coolIOVIter
def init(name):
"""Initialize the python binding with the callback previously registered
If no callback was registered, swallow the warning...
"""
klass = None
try: klass = _PyAthenaBindingsCatalog.instances[name]()
except KeyError:
ROOT = _import_ROOT()
from AthenaServices.Dso import registry
registry.load_type (name)
try:
import cppyy
#klass = getattr(ROOT, name)
klass = cppyy.makeClass(name)
except AttributeError:
raise AttributeError("no reflex-dict for type [%s]"%name)
return klass
def init(name):
"""Initialize the python binding with the callback previously registered
If no callback was registered, swallow the warning...
"""
klass = None
try:
klass = _PyAthenaBindingsCatalog.instances[name]()
except KeyError:
ROOT = _import_ROOT() # noqa: F841
from AthenaServices.Dso import registry
registry.load_type(name)
try:
import cppyy
#klass = getattr(ROOT, name)
klass = cppyy.makeClass(name)
except AttributeError:
raise AttributeError("no reflex-dict for type [%s]" % name)
return klass
def inspect(self, typename):
if self.debug: print 'inspecting ', typename
dontAdd = False
for b in self.blacklist:
if typename.find(b) == 0:
if self.debug: print 'blacklisted ', typename
dontAdd = True
# print self.classlist
if typename in self.classlist:
if self.debug: print 'seen before ', typename
dontAdd = True
try:
t = self.type.ByName(typename)
print t
if t.IsFundamental():
if self.debug: print typename, ' is fundamental'
return
if t.IsAbstract():
dontAdd = True
except:
pass
try:
cl = cppyy.makeClass(typename)
if not dontAdd: self.classlist.append(typename)
except:
print 'Cannot create class of ', typename
t = self.type.ByName(typename)
if t.IsComplete():
if self.debug: print typename, 'is complete'
else:
print typename, ' isn\'t complete'
if t.IsPointer():
if self.debug: print typename, ' is a pointer'
elif t.IsTypedef():
if self.debug: print typename, ' is typedef'
underlying = t.ToType()
if (underlying):
self.inspect(underlying.Name(7))
elif t.IsArray():
print typename, ' is an array'
elif t.IsTemplateInstance():
print typename, ' is template'
if typename.find('std::') == 0:
print 'std::business removed'
try:
self.classlist.remove(typename)
except:
pass
for i in range(t.TemplateArgumentSize()):
tt = t.TemplateArgumentAt(i)
ttname = tt.Name(7)
if tt.IsPointer() or tt.IsArray() or tt.IsTypedef():
ttname = tt.ToType().Name(7)
self.inspect(ttname)
elif t.IsClass():
if self.debug: print typename, ' is a class'
cname = t.Name(7)
if self.debug: print cname
for i in range(t.DataMemberSize()):
d = t.DataMemberAt(i)
dname = d.Name()
dtype = d.TypeOf().Name(7)
if self.debug:
print 'DataMember: ', dname, ' ', dtype, ' transient=', d.IsTransient(
)
if not d.IsTransient():
self.inspect(dtype)
else:
print 'what to do about ', typename, '?'
self.problemclasses.append(typename)
return
def __init__(self, t):
if type(t) is str: t = PyLCGDict.makeClass(t)
# print "type is string: ",t
# t = PyLCGDict.makeClass(t)
#t = PyLCGDict.makeClass(t)
self.type = t
def BadChan_SaveBadChannelCorrectionsToDatabase(self,dbstring,dbSvc,dbFolderName,selectedTag):
listKeys=self.dict_vectBadChanEntry.keys()
listKeys.sort()
# Create LArBadChannel object for defined BadChanEntry vector and coolChan
self.class_LArBadChannelState=cppyy.makeClass('LArBadChannelState')
inst_larBadChannelState=self.class_LArBadChannelState()
# Loop over cool channels
bNewDBCreated=False
for coolChan in listKeys:
vect_BadChanEntry=cppyy.gbl.std.vector('std::pair<HWIdentifier,LArBadChannel>')()
listHWidKeys=[x for x in self.dict_vectBadChanEntry[coolChan].keys()]
listHWidKeys.sort()
iNbCorrection=0
for key in listHWidKeys:
sHWid=key
if self.dict_vectBadChanEntry_Status[coolChan][sHWid]==STATUS_INIT:
badChan_word=self.dict_vectBadChanEntry_Init[coolChan][sHWid][1]
elif self.dict_vectBadChanEntry_Status[coolChan][sHWid]==STATUS_MODIFIED or self.dict_vectBadChanEntry_Status[coolChan][sHWid]==STATUS_NEW:
iNbCorrection += 1
badChan_word=self.dict_vectBadChanEntry[coolChan][sHWid][1]
elif self.dict_vectBadChanEntry_Status[coolChan][sHWid]==STATUS_REMOVED:
iNbCorrection += 1
continue
obj_HWid=self.class_HWIdentifier()
obj_HWid.set(sHWid)
larBadChannel=self.class_LArBadChannel(badChan_word)
pair_BadChanEntry=cppyy.gbl.pair('HWIdentifier,LArBadChannel')(obj_HWid, larBadChannel)
vect_BadChanEntry.push_back(pair_BadChanEntry)
# if correction were made => store BadChanEntry vector
if iNbCorrection>0:
for sEntry in vect_BadChanEntry:
inst_larBadChannelState.add(sEntry,coolChan)
else:
continue
# Create object based on new LArBadChannelState (via LArBadChannelDBTools python interface)
attrListSpec=cppyy.gbl.coral.AttributeListSpecification()
athenaAttrList=cppyy.gbl.AthenaAttributeList()
attrListSpec=self.nspace_LArBadChannelDBTools.createCoolSpec()
athenaAttrList=self.nspace_LArBadChannelDBTools.createPayload(inst_larBadChannelState.coolChannel(coolChan), attrListSpec)
# if save DB has not been created => do it
if bNewDBCreated is False:
try:
dbSave = dbSvc.createDatabase(dbstring)
except Exception as e:
print ('Problem opening database',e)
sys.exit(-1)
print ("Opened database",dbstring)
desc='<timeStamp>run-event</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>'
# Create cool spec from AttributeListSpec
coolSpec=cool.RecordSpecification()
for iElemt in range(0,attrListSpec.size()):
attrSpec=attrListSpec[iElemt]
typeName=attrSpec.typeName()
if typeName=="unsigned int":
coolSpec.extend(attrSpec.name(),cool.StorageType.UInt32)
elif typeName=="blob":
coolSpec.extend(attrSpec.name(),cool.StorageType.Blob64k)
else:
print ("Undefined cool.StorageType "+typeName)
# myfolder=dbSave.createFolder(dbFolderName, coolSpec, desc, cool.FolderVersioning.SINGLE_VERSION,True)
myfolder=dbSave.createFolder(dbFolderName, coolSpec, desc, cool.FolderVersioning.MULTI_VERSION,True)
import string
IOVBeginEnd=["90","9999999"]
beginRun = string.atoi(IOVBeginEnd[0]) << 32
endRun = string.atoi(IOVBeginEnd[1]) << 32
bNewDBCreated=True
# Create cool payload from AthenaAttributeList payload
coolPayload=cool.Record(coolSpec)
for iElemt in range(0,attrListSpec.size()):
attrSpec=attrListSpec[iElemt]
coolPayload[attrSpec.name()]=athenaAttrList[attrSpec.name()]
# Store cool object to folder
myfolder.storeObject(beginRun,endRun,coolPayload,coolChan,selectedTag)
# Close new databse
if bNewDBCreated is True:
dbSave.closeDatabase()
iovStop = "until " + str(ctime(stop.timestamp() / 1000000000))
except Exception, e:
print "## Caught exception [%s] !!" % str(e.__class__)
print "## What:", e
import sys
print sys.exc_info()[0]
print sys.exc_info()[1]
sc = 1
return "Invalid"
output = iovStart + iovStop
return output
if __name__ == "__main__":
t = cppyy.makeClass("IOVPayloadContainer")
# Add on iterators for the different containers
t.iter = iter
#print "t type ",t
t = cppyy.makeClass("CondAttrListCollection")
# Add on iterators for the different containers
t.attr_iter = attr_iter
t.iov_iter = iov_iter
t.name_iter = name_iter
t = cppyy.makeClass("std::set<unsigned int>")
t.iter = iter
#print "t type ",t
IOVRange = cppyy.makeClass('IOVRange')
IOVRange.iovPrint = iovPrint
# read in and treat options
def get_chain(self,counter, s):
#Prints chains and their information
ch = cppyy.makeClass('HLT::Chain')(s)
#ch.deserialize(s)
print (".... chain %-3d : %s Counter:%-4d Passed: %d (Raw:%d Prescaled: %d PassThrough:%d) Rerun: %d LastStep: %d Err: %s"\
% ( counter, self.HLT_Chain_Names[ch.getChainCounter()], ch.getChainCounter(), ch.chainPassed(), ch.chainPassedRaw(), ch.isPrescaled(), ch.isPassedThrough(), ch.isResurrected(), ch.getChainStep(), ch.getErrorCode().str()))
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
#### This is the dbgHLTResult class for the Debug Stream event analysis
from __future__ import print_function
from PyUtils import RootUtils
ROOT = RootUtils.import_root()
from ROOT import std
import cppyy
from CLIDComps.clidGenerator import clidGenerator
clidg = clidGenerator("")
cppyy.makeNamespace('HLT')
ActualHLTResult = cppyy.makeClass('HLT::HLTResult')
stringSerializer = cppyy.makeClass('StringSerializer')()
class hltResult(ActualHLTResult):
def __init__(self):
super(hltResult, self).__init__()
self.as_int_v = std.vector('unsigned int')()
def load(self, rob):
self.nav_payload = []
data = list(rob.rod_data())
self.as_int_v.clear()
self.as_int_v.reserve(len(data))
def commitToDb(self,
db,
folderPath,
tag,
bitPatVer,
author,
comment,
since,
until=(MAXRUN, MAXLBK),
untilCmt=None,
moduleList=[]):
"""
Commits the differences compared to the set of bad channels read in with the
initialze function to the provided database.
- author : author name (string)
- comment : a comment (string)
- sinceRun, sinceLbk : start of IOV for which bad channels are valid
- untilRun, untilLbk : end of IOV for which bad channels are valid
"""
#=== check db status
try:
if not db.isOpen():
raise Exception("DB not open: ", db.databaseId())
except Exception as e:
raise (e)
multiVersion = self.__multiVersion
writer = TileCalibTools.TileBlobWriter(db, folderPath, 'Bch',
multiVersion)
if len(comment) or isinstance(author, tuple):
writer.setComment(author, comment)
nUpdates = 0
goodComment = True
#=== get latest state from db
if moduleList != ['CMT']:
if since != (MINRUN, MINLBK):
justBefore = list(since)
if justBefore[1] > MINLBK:
justBefore[1] = justBefore[1] - 1
else:
justBefore[0] = justBefore[0] - 1
justBefore[1] = MAXLBK
justBefore = tuple(justBefore)
if self.__mode != 2:
self.log().info(
"Reading db state just before %s, i.e. at %s", since,
justBefore)
self.__updateFromDb(db, folderPath, tag, justBefore, 0)
else:
self.log().info(
"Using previous bad channel list from input DB")
self.log().info(
"And comparing it with new list of bad channels")
else:
if self.__mode != 2:
reader = TileCalibTools.TileBlobReader(db, folderPath, tag)
multiVersion = reader.folderIsMultiVersion()
self.log().info(
"Filling db from %s, resetting old status cache",
list(since))
self.__oldStat = len(self.__oldStat) * [TileBchStatus()]
#=== print status information
self.log().info("Committing changes to DB \'%s\'", db.databaseId())
self.log().info(
"... using tag \'%s\' and [run,lumi] range: [%i,%i] - [%i,%i]",
tag, since[0], since[1], until[0], until[1])
if isinstance(author, tuple) and len(author) == 3:
self.log().info("... author : \'%s\'", author[0])
self.log().info("... comment: \'%s\'", author[1])
else:
self.log().info("... author : \'%s\'", author)
self.log().info("... comment: \'%s\'", comment)
#=== default for drawer initialization
loGainDefVec = cppyy.gbl.std.vector('unsigned int')()
loGainDefVec.push_back(0)
hiGainDefVec = cppyy.gbl.std.vector('unsigned int')()
hiGainDefVec.push_back(0)
comChnDefVec = cppyy.gbl.std.vector('unsigned int')()
comChnDefVec.push_back(0)
cppyy.makeClass('std::vector<unsigned int>')
defVec = cppyy.gbl.std.vector('std::vector<unsigned int>')()
defVec.push_back(loGainDefVec)
defVec.push_back(hiGainDefVec)
defVec.push_back(comChnDefVec)
#=== loop over the whole detector
bchDecoder = TileBchDecoder(bitPatVer)
for ros in range(0, TileCalibUtils.max_ros()):
for mod in range(TileCalibUtils.getMaxDrawer(ros)):
modName = TileCalibUtils.getDrawerString(ros, mod)
nChange = self.checkModuleForChanges(ros, mod)
if nChange == 0 and (len(moduleList) == 0
or modName not in moduleList
or 'ALL' not in moduleList):
#=== do nothing if nothing changed
continue
if nChange == -1:
nUpdates += 1
self.log().info("Drawer %s reset to GOOD", modName)
if modName not in comment and not (
"ONL" not in folderPath
or "syncALL" not in comment):
goodComment = False
self.log().error(
"Comment string - '%s' - doesn't contain drawer %s",
comment, modName)
writer.zeroBlob(ros, mod)
else:
nUpdates += 1
self.log().info("Applying %2i changes to drawer %s",
nChange, modName)
if modName not in comment and ("ONL" not in folderPath
or "syncALL"
not in comment):
goodComment = False
self.log().error(
"Comment string - '%s' - doesn't contain drawer %s",
comment, modName)
drawer = writer.getDrawer(ros, mod)
drawer.init(defVec, TileCalibUtils.max_chan(),
bitPatVer)
for chn in range(TileCalibUtils.max_chan()):
#=== get low gain bit words
wordsLo = bchDecoder.encode(
self.getAdcStatus(ros, mod, chn, 0))
chBits = wordsLo[0]
loBits = wordsLo[1]
#=== get high gain bit words
wordsHi = bchDecoder.encode(
self.getAdcStatus(ros, mod, chn, 1))
chBits = wordsHi[0] | chBits
hiBits = wordsHi[1]
#=== set low, high and common channel word in calibDrawer
drawer.setData(chn, 0, 0, loBits)
drawer.setData(chn, 1, 0, hiBits)
drawer.setData(chn, 2, 0, chBits)
#=== synchronizing channel status in low and high gain
if wordsLo[0] != chBits:
self.log().info(
"Drawer %s ch %2d - sync LG status with HG ",
modName, chn)
status = TileBchStatus(
bchDecoder.decode(chBits, loBits))
self.setAdcStatus(ros, mod, chn, 0, status)
if wordsHi[0] != chBits:
self.log().info(
"Drawer %s ch %2d - sync HG status with LG ",
modName, chn)
status = TileBchStatus(
bchDecoder.decode(chBits, hiBits))
self.setAdcStatus(ros, mod, chn, 1, status)
#=== register
if nUpdates > 0 or moduleList == ['CMT']:
if goodComment:
self.log().info(
"Attempting to register %i modified drawers...", nUpdates)
if untilCmt is not None and untilCmt != until:
if moduleList != ['CMT'] and until > since:
writer.register(since, until, tag, 1)
if untilCmt > since:
writer.register(since, untilCmt, tag, -1)
else:
writer.register(since, until, tag)
else:
self.log().error(
"Aborting update due to errors in comment string")
else:
self.log().warning(
"No drawer modifications detected, ignoring commit request")
def print_chain(counter, s):
ch = cppyy.makeClass('HLT::Chain')(s)
#ch.deserialize(s)
print(".... chain %-3d Counter:%-4d Passed: %d (Raw:%d Prescaled: %d PassThrough:%d) Rerun: %d LastStep: %d Err: %s"\
% ( counter, ch.getChainCounter(), ch.chainPassed(), ch.chainPassedRaw(), ch.isPrescaled(), ch.isPassedThrough(),\
ch.isResurrected(), ch.getChainStep(), ch.getErrorCode().str()))
mlog = logging.getLogger('TrigConfigCheckInPool.py') ## get the logger
mlog.level = 1
MetaDataTree = ROOT.AthenaROOTAccess.TChainROOTAccess('MetaData')
def _iter(self):
sequential = self.begin()
end = self.end()
while sequential != end:
yield sequential.__deref__()
sequential.__preinc__()
raise StopIteration
_plcClass = cppyy.makeClass("IOVPayloadContainer")
_plcClass.iter = _iter
ROOT.IOVTime.__str__ = lambda x: "%i/%i" % (x.run(), x.event())
ROOT.IOVRange.__str__ = lambda x: "%s - %s" % (x.start(), x.stop())
def checkPoolFileForRunLevel(poolfilename):
folderName = {
"L1M": "_TRIGGER_LVL1_Menu",
"HLTM": "_TRIGGER_HLT_Menu",
"L1K": "_TRIGGER_LVL1_Lvl1ConfigKey",
"HLTK": "_TRIGGER_HLT_HltConfigKeys",
"L1PS": "_TRIGGER_LVL1_Prescales"
}
MetaDataTree.Add(poolfilename + '/MetaData')
#=== print status information
self.log().info("Committing changes to DB \'%s\'" % db.databaseId())
self.log().info(
"... using tag \'%s\' and [run,lumi] range: [%i,%i] - [%i,%i]" %
(tag, since[0], since[1], until[0], until[1]))
self.log().info("... author : \'%s\'" % author)
self.log().info("... comment: \'%s\'" % comment)
#=== default for drawer initialization
loGainDefVec = cppyy.gbl.std.vector('unsigned int')()
loGainDefVec.push_back(0)
hiGainDefVec = cppyy.gbl.std.vector('unsigned int')()
hiGainDefVec.push_back(0)
comChnDefVec = cppyy.gbl.std.vector('unsigned int')()
comChnDefVec.push_back(0)
cppyy.makeClass('std::vector<unsigned int>')
defVec = cppyy.gbl.std.vector('std::vector<unsigned int>')()
defVec.push_back(loGainDefVec)
defVec.push_back(hiGainDefVec)
defVec.push_back(comChnDefVec)
#=== loop over the whole detector
writer = TileCalibTools.TileBlobWriter(db, folderPath, 'Bch',
multiVersion)
if len(comment): writer.setComment(author, comment)
bchDecoder = TileBchDecoder(bitPatVer)
nUpdates = 0
goodComment = True
for ros in xrange(0, TileCalibUtils.max_ros()):
for mod in xrange(TileCalibUtils.getMaxDrawer(ros)):
modName = TileCalibUtils.getDrawerString(ros, mod)
def initialize(self):
## note that we are using the python logging service
## and that the PyAthena.Alg base class has already initialized
## it for us
# Get DetectorStore...
from StoreGateBindings.Bindings import StoreGate
self._detStore = StoreGate.pointer("DetectorStore")
if self._detStore is None:
self.msg.error("Failed to get DetectorStore")
return StatusCode.Failure
# Get LArOnlineID helper class
self.onlineID = self._detStore.retrieve("LArOnlineID", "LArOnlineID")
if self.onlineID is None:
self.msg.error("Failed to get LArOnlineID")
return StatusCode.Failure
# Get CaloCell_ID
self.offlineID = self._detStore.retrieve("CaloCell_ID", "CaloCell_ID")
if self.offlineID is None:
self.msg.error("Failed to get CaloCell_ID")
return StatusCode.Failure
# -----------------------------------------------------------
# Initialize LArCabling service
self.larCablingSvc = PyAthena.py_tool("LArCablingService")
if self.larCablingSvc is None:
self.msg.error('Problem retrieving LArCablingService pointer !')
return StatusCode.Failure
else:
self.msg.info('retrieved [%s]', self.larCablingSvc.name())
self.badChannelTool = PyAthena.py_tool("LArBadChanTool",
iface="ILArBadChanTool")
if self.badChannelTool is None:
self.msg.error('Problem retrieving LArBadChanTool pointer !')
return StatusCode.Failure
else:
self.msg.info('retrieved [%s]', self.badChannelTool.name())
self.class_larBCBitPacking = cppyy.makeClass("LArBadChanBitPacking")
self.bc_packing = self.class_larBCBitPacking()
self.noisepattern = 0L
for n in ("lowNoiseHG", "highNoiseHG", "unstableNoiseHG", "lowNoiseMG",
"highNoiseMG", "unstableNoiseMG", "lowNoiseLG",
"highNoiseLG", "unstableNoiseLG", "sporadicBurstNoise"):
stat = self.bc_packing.enumName(n)
if stat[0]:
self.noisepattern |= 1 << stat[1]
self.deadpattern = 0L
for n in ("deadReadout", "deadPhys", "almostDead"):
stat = self.bc_packing.enumName(n)
if stat[0]:
self.deadpattern |= 1 << stat[1]
self.noid = Identifier()
if self.includeLocation:
try:
self.caloDDM = CaloDetDescrManager.instance()
except:
print "Failed to retrieve CaloDDM"
return StatusCode.Failure
self.larPedestal = None
self.larMphysOverMcal = None
self.larRamp = None
self.larDAC2uA = None
self.laruA2MeV = None
self.larhvScaleCorr = None
self.larDSPThr = None
return StatusCode.Success
#=== folder tag suffix
tagCon = "LARTimeCorrectionOflNonRunCon-00"
tagRun = "LARTimeCorrectionOflRunCon-00"
#=== values for the comment channel
author = "dhu"
comment = "Updated time constant values"
#==================================================
#===
#=== Code starts below here
#===
#==================================================
#=== set shortcut
g = cppyy.gbl
cppyy.makeClass('std::vector<float>')
#=== get a logger
log = CaloCondLogger.getLogger("CaloTimeConsWriter")
#=== (re-)create the database
db = CaloCondTools.openDb('SQLITE', 'COMP200', 'UPDATE')
try:
#=== creating folder specifications
spec = cool.RecordSpecification()
spec.extend( 'CaloCondBlob16M', cool.StorageType.Blob16M )
#=== create the folder
folderPath = CaloCondTools.getCaloPrefix()+"LAR/TimeCorrectionOfl/NonRunCon"
folderTag = tagCon
def execute(self):
self.msg.info('running execute...')
self.msg.info('dumping [%s] content', self.sg.name())
self.msg.info(self.sg.dump())
listOfFolders = [
"/LAR/BadChannels/BadChannels", "/LAR/BadChannels/MissingFEBs"
]
iSelectedFolder = LArBadChannelBrowserTools.ChooseOptionFromList(
"Folder list : ", "", "", listOfFolders, +1, False, {})
if iSelectedFolder == 1:
self.dbFolderName = "/LAR/BadChannels/BadChannels"
self.folderId = BAD_CHANNEL
else:
self.dbFolderName = "/LAR/BadChannels/MissingFEBs"
self.folderId = MISSING_FEB
# -----------------------------------------------------------
# Browse database a first time to catch tags name and IOV
listOfTags, dictIOV, self.iNbCoolChannel = self.GetTagsAndIOVFromDatabase(
self.dbFolderName)
# -----------------------------------------------------------
# Create an objec instance for all interfaced python classes
LArBadChannelDBTools = cppyy.makeNamespace('LArBadChannelDBTools')
self.nspace_LArBadChannelDBTools = LArBadChannelDBTools()
self.class_LArBadChannel = cppyy.makeClass('LArBadChannel')
self.class_HWIdentifier = cppyy.makeClass('HWIdentifier')
self.class_LArBadChanBitPacking = cppyy.makeClass(
"LArBadChanBitPacking")
if self.folderId == BAD_CHANNEL:
self.dbBrowserBadChan = LArDBFolderBrowser_BadChan.LArDBFolderBrowser_BadChan(
self.nspace_LArBadChannelDBTools,
self.class_LArBadChanBitPacking, self.class_LArBadChannel,
self.class_HWIdentifier, self.onlineID, self.larCablingSvc,
self.msg)
elif self.folderId == MISSING_FEB:
self.dbBrowserMissingFeb = LArDBFolderBrowser_MissingFEBs.LArDBFolderBrowser_MissingFEBs(
self.nspace_LArBadChannelDBTools,
self.class_LArBadChanBitPacking,
self.class_LArBadChannel,
self.class_HWIdentifier,
self.onlineID,
self.larCablingSvc,
)
# -----------------------------------------------------------
# Select the tag
iSelectedTag = LArBadChannelBrowserTools.ChooseOptionFromList(
"Tag list : ", "", "", listOfTags, +1, False, {})
if iSelectedTag < 1:
return
self.selectedTag = listOfTags[iSelectedTag - 1]
# -----------------------------------------------------------
# Construct IOV list based on selected tag
self.tagIOVDict = {}
for iChannel in range(0, self.iNbCoolChannel):
self.tagIOVDict[iChannel] = dictIOV[
self.selectedTag][iChannel][-1][0]
# -----------------------------------------------------------
# Show database content
self.channelNameDict = self.ReadObjectsFromDatabase(
self.dbFolderName, self.selectedTag, self.tagIOVDict)
if self.folderId == BAD_CHANNEL:
self.dbBrowserBadChan.BadChan_SetChannelNameDict(
self.channelNameDict)
# sMessage="IOV : "+str(self.tagIOVDict)+" / channel : "+str(self.channelNameDict)
# LArBadChannelBrowserTools.TypeEnterToContinue(sMessage)
# -------------------------------------------------------------------------------------
#
# LOOP OVER COOL CHANNEL MODIFICATIONS
#
# -------------------------------------------------------------------------------------
bEndOfCoolChannelModification = False
while not bEndOfCoolChannelModification:
# -----------------------------------------------------------
# MISSING_FEB : go to correction menu
if self.folderId == MISSING_FEB: #
coolChan = 0
self.dbBrowserMissingFeb.MissingFeb_DisplayMissingFeb(coolChan)
endOfModif = self.dbBrowserMissingFeb.MissingFeb_ModifyMissingFeb(
coolChan)
if endOfModif == 'q':
sDBName = os.environ["PWD"] + "/MissingFebUpdate.db"
if os.path.isfile(sDBName):
os.remove(sDBName)
dbstring = "sqlite://;schema=" + sDBName + ";dbname=BADCHAN"
self.dbBrowserMissingFeb.MissingFeb_SaveMissingFebCorrectionsToDatabase(
dbstring, self.dbSvc, self.dbFolderName,
self.selectedTag)
self.dbBrowserMissingFeb.MissingFeb_CheckSavedDatabaseContent(
dbstring, self.dbSvc, self.dbFolderName,
self.selectedTag)
return
# -----------------------------------------------------------
# Select Cool channel
sCoolChannelMenuDict = [("s", "(summary)"), ("a", "(abort)"),
("q", "(save and quit)")]
listCoolChannel = []
for i in range(0, self.iNbCoolChannel):
listCoolChannel.append(self.channelNameDict[i] + " (IOV " +
str(self.tagIOVDict[i]) + ")")
repCoolChan = LArBadChannelBrowserTools.ChooseOptionFromList(
"Cool channel list : ", "", "", listCoolChannel, 0, False,
sCoolChannelMenuDict)
if repCoolChan == "a":
iAbortConfirmation = LArBadChannelBrowserTools.YesNoQuestion(
"Are you sure you want to quit ? ")
if iAbortConfirmation == 1:
return
elif repCoolChan == "q":
print(" SAUVEGARDE FINALE")
if self.folderId == BAD_CHANNEL:
sDBName = os.environ["PWD"] + "/BadChannelUpdate.db"
if os.path.isfile(sDBName):
os.remove(sDBName)
dbstring = "sqlite://;schema=" + sDBName + ";dbname=BADCHAN"
self.dbBrowserBadChan.BadChan_SaveBadChannelCorrectionsToDatabase(
dbstring, self.dbSvc, self.dbFolderName,
self.selectedTag)
self.dbBrowserBadChan.BadChan_CheckSavedDatabaseContent(
dbstring, self.dbSvc, self.dbFolderName,
self.selectedTag)
bEndOfCoolChannelModification = True
elif repCoolChan == "s":
for i in range(0, self.iNbCoolChannel):
self.dbBrowserBadChan.BadChan_ShowBadChannelCorrectionsSummary(
i)
else:
# -----------------------------------------------------------
# Display selected Cool channel
coolChan = int(repCoolChan)
if self.folderId == BAD_CHANNEL:
self.dbBrowserBadChan.BadChan_DisplayBadChanEntry(coolChan)
self.dbBrowserBadChan.BadChan_ModifyLarBadChannel(coolChan)
default='',
help="2nd file for the comparison")
optparser.add_option("",
"--ef",
action="store_true",
default=False,
help="Use EF result instead of L2")
(opt, args) = optparser.parse_args()
res = hltResult()
featureSizes = {}
stats = {}
HLTChain = cppyy.makeClass('HLT::Chain')
def my_dump(bsfile):
"""Runs the dumping routines"""
# open a file
print "=" * 100
print "Opening", bsfile
events = {}
input = eformat.istream(bsfile)
subdet = eformat.helper.SubDetector.TDAQ_EVENT_FILTER if opt.ef else eformat.helper.SubDetector.TDAQ_LVL2
for event in input:
