def defineFolderSpec( isMultiVersion ): recordSpec = cool.RecordSpecification() recordSpec.extend( "Offset", ST.Float ) folderSpec = cool.FolderSpecification( FV.MULTI_VERSION if isMultiVersion else FV.SINGLE_VERSION, recordSpec ) recordSpec2 = cool.RecordSpecification() recordSpec2.extend( "Noise", ST.Blob64k ) folderSpec2 = cool.FolderSpecification( FV.MULTI_VERSION if isMultiVersion else FV.SINGLE_VERSION, recordSpec2 ) return ( folderSpec, folderSpec2 )
def execute(self): folder = '/DMTest/TestAttrList' # do update - setup folder specification and create if needed spec = cool.RecordSpecification() spec.extend("xint", cool.StorageType.Int32) print(">== Store object in folder", folder) cfolder = AtlCoolLib.ensureFolder( self.db, folder, spec, AtlCoolLib.athenaDesc(self.runLumi, 'AthenaAttributeList'), cool.FolderVersioning.MULTI_VERSION) if (cfolder is None): sys.exit(1) # now write data payload = cool.Record(spec) payload['xint'] = self.xint print('>== Store object with IOV [', self.since, ',', self.until, '] and tag', self.tag, 'xint', self.xint) try: if (self.tag == "HEAD"): cfolder.storeObject(self.since, self.until, payload, 0) else: cfolder.storeObject(self.since, self.until, payload, 0, self.tag) print(">== Storing COOL object succeeded. Current content:") except Exception: import traceback traceback.print_exc() print('>== Storing COOL object FAILED') sys.exit(1) # print full content act = AtlCoolTool.AtlCoolTool(self.db) print(act.more(folder))
def execute(self): chanlist = self.getchans() if len(chanlist) == 0: sys.exit(1) # now do update - setup folder specification and create if needed spec = cool.RecordSpecification() spec.extend("NBuilt", cool.StorageType.Int32) print ">== Store object in folder", self.foldername cfolder = AtlCoolLib.ensureFolder( self.db, self.foldername, spec, AtlCoolLib.athenaDesc(True, 'CondAttrListCollection') + '<named/>', cool.FolderVersioning.SINGLE_VERSION) if (cfolder is None): sys.exit(1) # if we do not have data to add - finish here if (not self.isdata): return # now write data payload = cool.Record(spec) payload['NBuilt'] = self.nbuilt for channel in chanlist: print '>== Store object with IOV [', self.since, ',', self.until, '] channel', channel, 'NBuilt=', self.nbuilt try: cfolder.storeObject(self.since, self.until, payload, channel) except Exception, e: print e print 'Exception thrown when storing for channel', channel print '>== Storing COOL object FAILED' sys.exit(1)
def build_folder(cls, db, folder_name, multiversion, record): """ Create `folder_name` on database instance `db`, with recordspecification `record`. Also creates folderset to which folder_name belongs if necessary. """ from PyCool import cool folderset_path = dirname(folder_name) try: db.getFolderSet(folderset_path) except Exception as error: caught_error = "Folder set %s not found" % folderset_path if caught_error not in error.args[0]: raise log.debug("Folderset doesn't exist - creating it.") db.createFolderSet(folderset_path, "", True) if not isinstance(record, cool.RecordSpecification): record_spec = cool.RecordSpecification() for field in record: record_spec.extend(*field) else: record_spec = record FV = cool.FolderVersioning versioning = FV.MULTI_VERSION if multiversion else FV.SINGLE_VERSION folder_spec = cool.FolderSpecification(versioning, record_spec) folder = db.createFolder(folder_name, folder_spec) payload = cool.Record(record_spec) return folder, payload
def createDB(): """Create sqlite file with DCS currents""" from PyCool import cool from CoolConvUtilities import AtlCoolLib, AtlCoolTool # Cleanup previous file import os if os.path.isfile("magfield.db"): os.remove("magfield.db") db = cool.DatabaseSvcFactory.databaseService().createDatabase( 'sqlite://;schema=magfield.db;dbname=CONDBR2') spec = cool.RecordSpecification() spec.extend("value", cool.StorageType.Float) spec.extend("quality_invalid", cool.StorageType.Bool) f = AtlCoolLib.ensureFolder( db, folder, spec, AtlCoolLib.athenaDesc(True, 'CondAttrListCollection')) for v in currents: sol = cool.Record(spec) sol['value'] = v[1] sol['quality_invalid'] = False tor = cool.Record(spec) tor['value'] = v[2] tor['quality_invalid'] = False f.storeObject(v[0], cool.ValidityKeyMax, sol, 1) # channel 1 f.storeObject(v[0], cool.ValidityKeyMax, tor, 3) # channel 3 # print database content act = AtlCoolTool.AtlCoolTool(db) print(act.more(folder))
def createSqlite(sqliteName,folderName="/TDAQ/OLC/LHC/FILLPARAMS"): dbSvc = cool.DatabaseSvcFactory.databaseService() if os.access(sqliteName,os.R_OK): print ("UPDATING existing sqlite file %s" % sqliteName) db=dbSvc.openDatabase("sqlite://;schema="+sqliteName+";dbname=CONDBR2",False) else: print("Creating new sqlite file %s" % sqliteName) db=dbSvc.createDatabase("sqlite://;schema="+sqliteName+";dbname=CONDBR2") pass spec = cool.RecordSpecification() spec.extend("Beam1Bunches",cool.StorageType.UInt32) spec.extend("Beam2Bunches",cool.StorageType.UInt32) spec.extend("LuminousBunches",cool.StorageType.UInt32) spec.extend("BCIDmasks",cool.StorageType.Blob64k) descr='<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' if db.existsFolder(folderName): folder=db.getFolder(folderName) else: print("Creating COOL folder/tag %s" % (folderName)) #folder = db.createFolder(folderName, spec, desc, cool.FolderVersioning.MULTI_VERSION, True) folderSpec = cool.FolderSpecification(cool.FolderVersioning.SINGLE_VERSION, spec) folder = db.createFolder(folderName, folderSpec, descr, True) pass return db,folder
def store_PID_to_folder(db, values_list): """ Function to create folder FOLDER_NAME in db with channels and input data from values_list with tag TAG_NAME :param db: Open cool db :param values_list: list of tuples ('channel name', valus array) """ spec = cool.RecordSpecification() spec.extend('array_value', cool.StorageType.Float) _logger.info('Create folder %s' % FOLDER_NAME) folder_spec = cool.FolderSpecification(cool.FolderVersioning.MULTI_VERSION, spec, cool.PayloadMode.VECTORPAYLOAD) folder = db.createFolder( FOLDER_NAME, folder_spec, ' <timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="55403898"/></addrHeader><typeName>CondAttrListVec</typeName>', True) for index, channel_name in enumerate(values_list): folder.createChannel(index, channel_name[0]) print '%i - %s' % (index, channel_name[0]) folder.setupStorageBuffer() for index, channel_values in enumerate(values_list): _logger.info('Store data from %s' % channel_values[0]) values = channel_values[1] # print channel_values[0] # print channel_values[1] vector = cool.IRecordVector() for value in values: # print value data = cool.PyCool.Helpers.IRecordPtr(spec) data.get()['array_value'] = value vector.push_back(data) folder.storeObject(0, cool.ValidityKeyMax, vector, index, TAG_NAME) folder.flushStorageBuffer()
def createRPCConditionDB(): import os from PyCool import cool # get database service and open database dbSvc = cool.DatabaseSvcFactory.databaseService() # database accessed via physical name dbstring = 'sqlite://;schema=RPCConditionDB.db;dbname=RPC_DQA' if os.access('RPCConditionDB.db', os.R_OK): try: os.unlink('RPCConditionDB.db') except Exception as e: print('Unable to remove existing db file, reason', e) try: db = dbSvc.createDatabase(dbstring) except Exception as e: print('Problem creating database', e) return print("Created database", dbstring) spec2 = cool.RecordSpecification() spec2.extend("PanelRes", cool.StorageType.String255) spec2.extend("StripStatus", cool.StorageType.String4k) desc = "<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type=\"71\" clid=\"1238547719\" /></addrHeader><typeName>CondAttrListCollection</typeName>" # create the folder - single version # last argument is createParents - if true, automatically creates parent # folders if needed # note this will not work if the database already exists - delete mycool.db first # Deprecated/dropped: myfolder=db.createFolder('/OFFLINE/FINAL',spec2,desc,cool.FolderVersioning.MULTI_VERSION,True) folderSpec = cool.FolderSpecification(cool.FolderVersioning.MULTI_VERSION, spec2) db.createFolder('/OFFLINE/FINAL', folderSpec, desc, True) db.closeDatabase()
def defineFolderSpecTypeName(Name, Type, isMultiVersion): recordSpec = cool.RecordSpecification() # recordSpec.extend( "Maps", ST.Float ) recordSpec.extend(Name, Type) folderSpec = cool.FolderSpecification( FV.MULTI_VERSION if isMultiVersion else FV.SINGLE_VERSION, recordSpec) return (folderSpec)
def createFolder(db, name): desc = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader><typeName>CondAttrListCollection</typeName>' spec = cool.RecordSpecification() spec.extend('LBAvInstLumi', cool.StorageType.Float) spec.extend('Valid', cool.StorageType.UInt32) folderSpec = cool.FolderSpecification(cool.FolderVersioning.MULTI_VERSION, spec) #return db.createFolder(name,spec,desc,cool.FolderVersioning.MULTI_VERSION, True) return db.createFolder(name, folderSpec, desc, True)
def __init__(self, db, folderPath, caloBlobType=None, isMultiVersionFolder=True, isRunLumiTimeStamp=True): """ Input: - db : db should be an open database connection - folderPath: full folder path to create or update """ #=== initialize base class CaloCondLogger.__init__(self, "CaloBlobWriter") #=== store db self.__db = db #=== determine folder mode folderMode = cool.FolderVersioning.MULTI_VERSION if not isMultiVersionFolder: folderMode = cool.FolderVersioning.SINGLE_VERSION #=== determine folder description folderDescr = getAthenaFolderDescr() #=== access folder in db try: #=== create folder if it does not exist if self.__db.existsFolder(folderPath): self.__folder = self.__db.getFolder(folderPath) #=== check folder mode modeInCool = self.__folder.versioningMode() if modeInCool != folderMode: str = "Incompatible folder mode detected, COOL folder has type " if modeInCool == cool.FolderVersioning.MULTI_VERSION: str += "MULTI" else: str += "SINGLE" raise Exception(str) else: #=== create folder if it does not exist payloadSpec = cool.RecordSpecification() payloadSpec.extend('CaloCondBlob16M', cool.StorageType.Blob16M) folderSpec = cool.FolderSpecification(folderMode, payloadSpec) self.__folder = db.createFolder(folderPath, folderSpec, folderDescr, True) except Exception as e: self.log().critical(e) raise #=== initialize channel dictionaries self.__chanDictRecord = {} # <int, cool.Record > self.__chanDictCells = {} # <int, CaloCondBlobFlt>
def _create_defect_logic_folder(self, db): """ Creates the COOL database/folder for virtual defect logic, if they don't exist. Internal - use create=True in the constructor to create the COOL folder. """ log.info("Creating defect logic folder") record_spec = cool.RecordSpecification() record_spec.extend("clauses", ST.String4k) folder_spec = cool.FolderSpecification(FV.MULTI_VERSION, record_spec) return db.createFolder(DEFECT_LOGIC_FOLDER, folder_spec, DEFECT_LOGIC_FOLDER_DESC, True)
def write_geometry(self, new_file_name): print(" Writing geometry to file ", new_file_name) dbSvc = cool.DatabaseSvcFactory.databaseService() connectString = 'sqlite://;schema=' + new_file_name + ';dbname=L1CALO' print('Writing into database file', new_file_name) db = dbSvc.openDatabase(connectString, False) spec = cool.RecordSpecification() spec.extend('NLayers', cool.StorageType.UChar) spec.extend('Name1', cool.StorageType.UChar) spec.extend('Name2', cool.StorageType.UChar) spec.extend('Name3', cool.StorageType.UChar) spec.extend('Name4', cool.StorageType.UChar) spec.extend('NCells1', cool.StorageType.UChar) spec.extend('NCells2', cool.StorageType.UChar) spec.extend('NCells3', cool.StorageType.UChar) spec.extend('NCells4', cool.StorageType.UChar) now = int(time.time()) since = now * self.UNIX2COOL until = cool.ValidityKeyMax folder_description = "<timeStamp>time</timeStamp><addrHeader><address_header service_type=\"71\" clid=\"1238547719\"/></addrHeader><typeName>CondAttrListCollection</typeName>" f = db.createFolder("/TRIGGER/L1Calo/V1/Results/RxLayers", spec, folder_description) for i in self.NLayers.keys(): data = cool.Record(spec) data['NLayers'] = struct.pack('B', self.NLayers[i]) data['Name1'] = struct.pack('B', self.LayerName[i][0]) data['Name2'] = struct.pack('B', self.LayerName[i][1]) data['Name3'] = struct.pack('B', self.LayerName[i][2]) data['Name4'] = struct.pack('B', self.LayerName[i][3]) data['NCells1'] = struct.pack('B', self.NCells[i][0]) data['NCells2'] = struct.pack('B', self.NCells[i][1]) data['NCells3'] = struct.pack('B', self.NCells[i][2]) data['NCells4'] = struct.pack('B', self.NCells[i][3]) f.storeObject(since, until, data, int(i, 16)) db.closeDatabase() return
def tests(): print 'AtlCoolLib tests' db = forceOpen("TESTCOOL") if (db is None): print 'Could not create test database' sys.exit(1) spec = cool.RecordSpecification() spec.extend('testString', cool.StorageType.String255) folder = ensureFolder(db, '/TEST/TEST1', spec, athenaDesc(True, 'CondAttrListCollection'), cool.FolderVersioning.MULTI_VERSION) if (folder is None): print 'Could not create test folder' sys.exit(1) print 'All done' return
def _create_defects_folder(self, db): """ Creates the COOL database/folder for defects, if they don't exist. Internal - use create=True in the constructor to create the COOL folder. """ log.info("Creating defects folder") record_spec = cool.RecordSpecification() record_spec.extend("present", ST.Bool) record_spec.extend("recoverable", ST.Bool) record_spec.extend("user", ST.String255) record_spec.extend("comment", ST.String255) folder_spec = cool.FolderSpecification(FV.MULTI_VERSION, record_spec) return db.createFolder(DEFECTS_FOLDER, folder_spec, DEFECT_FOLDER_DESC, True)
def execute(self): # do update - setup folder specification and create if needed spec = cool.RecordSpecification() spec.extend("status", cool.StorageType.Int32) spec.extend("posX", cool.StorageType.Float) spec.extend("posY", cool.StorageType.Float) spec.extend("posZ", cool.StorageType.Float) spec.extend("sigmaX", cool.StorageType.Float) spec.extend("sigmaY", cool.StorageType.Float) spec.extend("sigmaZ", cool.StorageType.Float) spec.extend("tiltX", cool.StorageType.Float) spec.extend("tiltY", cool.StorageType.Float) spec.extend("sigmaXY", cool.StorageType.Float) folder = '/Indet/Beampos' print ">== Store object in folder", folder cfolder = AtlCoolLib.ensureFolder( self.db, folder, spec, AtlCoolLib.athenaDesc(self.runLumi, 'AthenaAttributeList'), cool.FolderVersioning.MULTI_VERSION) if (cfolder is None): sys.exit(1) # now write data payload = cool.Record(spec) payload['status'] = self.status payload['posX'] = self.posx payload['posY'] = self.posy payload['posZ'] = self.posz payload['sigmaX'] = self.sigmax payload['sigmaY'] = self.sigmay payload['sigmaZ'] = self.sigmaz payload['tiltX'] = self.tiltx payload['tiltY'] = self.tilty payload['sigmaXY'] = self.sigmaxy print '>== Store object with IOV [', self.since, ',', self.until, '] and tag', self.tag, 'status', self.status print '>== Beamspot position (mm):', self.posx, self.posy, self.posz print '>== Beamspot sigma (mm):', self.sigmax, self.sigmay, self.sigmaz print '>== Beamspot tilt (rad):', self.tiltx, self.tilty try: if (self.tag == "HEAD"): cfolder.storeObject(self.since, self.until, payload, 0) else: cfolder.storeObject(self.since, self.until, payload, 0, self.tag) print ">== Storing COOL object succeeded" except Exception, e: print e print '>== Storing COOL object FAILED' sys.exit(1)
def __init__(self): self.records = [] self.iovStartRun = 0 self.iovStartLumiBlock = 0 self.iovEndRun = 0 self.iovEndLumiBlock = 0 self.tag = "AFPTest-00-00-00" self.folderName = "/FWD/AFP/TEST" self.spec = cool.RecordSpecification() # self.spec.extend("data", cool.StorageType.Blob64k) self.spec.extend("data", cool.StorageType.String16M) # self.desc = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader><typeName>CondAttrListCollection</typeName>' self.desc = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' self.data = cool.Record(self.spec) self.folderSpec = cool.FolderSpecification( cool.FolderVersioning.MULTI_VERSION, self.spec)
def openBeamSpotDbFile(fileName, forceNew=False, folderName='/Indet/Beampos', dbName='BEAMSPOT'): """Open a beam spot SQLite COOL file and get a `folderHandle` to the beam spot folder. If the folder doesn't exist yet, it is created. If the SQLite file doesn't exist, it is created. If forceNew=True, any previously existing output file with the specified name is overwritten.""" connString = 'sqlite://;schema=%s;dbname=%s' % (fileName, dbName) dbSvc = cool.DatabaseSvcFactory.databaseService() if forceNew and os.path.exists(fileName): os.remove(fileName) if os.path.exists(fileName): db = dbSvc.openDatabase(connString, False) else: db = dbSvc.createDatabase(connString) # Make sure we have /Indet/Beampos with the correct schema spec = cool.RecordSpecification() spec.extend("status", cool.StorageType.Int32) spec.extend("posX", cool.StorageType.Float) spec.extend("posY", cool.StorageType.Float) spec.extend("posZ", cool.StorageType.Float) spec.extend("sigmaX", cool.StorageType.Float) spec.extend("sigmaY", cool.StorageType.Float) spec.extend("sigmaZ", cool.StorageType.Float) spec.extend("tiltX", cool.StorageType.Float) spec.extend("tiltY", cool.StorageType.Float) spec.extend("sigmaXY", cool.StorageType.Float) spec.extend("posXErr", cool.StorageType.Float) spec.extend("posYErr", cool.StorageType.Float) spec.extend("posZErr", cool.StorageType.Float) spec.extend("sigmaXErr", cool.StorageType.Float) spec.extend("sigmaYErr", cool.StorageType.Float) spec.extend("sigmaZErr", cool.StorageType.Float) spec.extend("tiltXErr", cool.StorageType.Float) spec.extend("tiltYErr", cool.StorageType.Float) spec.extend("sigmaXYErr", cool.StorageType.Float) folder = AtlCoolLib.ensureFolder( db, folderName, spec, AtlCoolLib.athenaDesc(True, 'AthenaAttributeList'), cool.FolderVersioning.MULTI_VERSION) folderHandle = (db, folder, spec) return folderHandle
def createSqlite(sqliteName, folderName, foldertag, iovMin=cool.ValidityKeyMin, iovMax=cool.ValidityKeyMax, inputFileName=None, defaultvalue=1.0): dbSvc = cool.DatabaseSvcFactory.databaseService() if os.access(sqliteName, os.R_OK): print("UPDATING existing sqlite file", sqliteName) db = dbSvc.openDatabase( "sqlite://;schema=" + sqliteName + ";dbname=CONDBR2", False) else: print("Creating new sqlite file", sqliteName) db = dbSvc.createDatabase("sqlite://;schema=" + sqliteName + ";dbname=CONDBR2") spec = cool.RecordSpecification() spec.extend('CaloCondBlob16M', cool.StorageType.Blob16M) desc = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' if db.existsFolder(folderName): folder = db.getFolder(folderName) else: print("Creating COOL folder/tag %s/%s" % (folderName, foldertag)) #folder = db.createFolder(folderName, spec, desc, cool.FolderVersioning.MULTI_VERSION, True) folderSpec = cool.FolderSpecification( cool.FolderVersioning.MULTI_VERSION, spec) folder = db.createFolder(folderName, folderSpec, desc, True) pass if inputFileName is None or len(inputFileName) == 0: print("No input given. Create empty blob") data = cool.Record(spec) else: data = CaloCondBlobWriterFromFile(spec, inputFileName, defaultvalue) print("Storing CaloCondBlob object") folder.storeObject(iovMin, iovMax, data, cool.ChannelId(0), foldertag, True) db.closeDatabase()
def WriteSqlite(name, input_dict): UNIX2COOL = 1000000000 dbSvc = cool.DatabaseSvcFactory.databaseService() connectString = 'sqlite://;schema=' + name + ';dbname=L1CALO' # folder_name="/TRIGGER/Receivers/Factors/CalibGains" print('\nrecreating database file:', name) dbSvc.dropDatabase(connectString) db = dbSvc.createDatabase(connectString) spec = cool.RecordSpecification() spec.extend("factor", cool.StorageType.Float) spec.extend("status", cool.StorageType.UInt32) folderSpec = cool.FolderSpecification(cool.FolderVersioning.SINGLE_VERSION, spec) now = int(time.time()) since = now * UNIX2COOL # since = 0 # until = sys.maxint until = cool.ValidityKeyMax db.createFolderSet('/TRIGGER') db.createFolderSet('/TRIGGER/Receivers') db.createFolderSet('/TRIGGER/Receivers/Factors') folder_description = '<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="1238547719"/></addrHeader><typeName>CondAttrListCollection</typeName>' f = db.createFolder("/TRIGGER/Receivers/Factors/CalibGains", folderSpec, folder_description) print(" Now creating sqlite file for ", len(input_dict.keys()), " channels") for i in input_dict.keys(): data = cool.Record(spec) data['factor'] = input_dict[i][0] data['status'] = input_dict[i][1] f.storeObject(since, until, data, int(i, 16)) db.closeDatabase()
def execute(self): print '>== Inserting reference to file:', self.file, ' - find GUID' os.system('coolHist_extractFileIdentifier.sh %s' % self.file) guid = open('coolhist_guid.tmp', 'r').readline()[:-1] if (guid == 'none'): print '>== File has no GUID - aborting' sys.exit(1) # setup folder specification and create if needed spec = cool.RecordSpecification() spec.extend("fileGUID", cool.StorageType.String4k) cfolder = AtlCoolLib.ensureFolder( self.db, self.folder, spec, AtlCoolLib.athenaDesc(self.runLumi, 'CondAttrListCollection') + '<named/>', cool.FolderVersioning.MULTI_VERSION) print if (cfolder is None): sys.exit(1) # check if channel number needs to be looked up if (self.channelstr != ""): try: self.channel = cfolder.channelId(self.channelstr) print '>== Channel name', self.channelstr, 'is channelId', self.channel except Exception: print 'Non-existant or invalid channel name:', self.channelstr sys.exit(1) print '>== Write data on COOL connection:', self.conn print '>== To folder:', self.folder, 'channel:', self.channel print '>== COOL tag:', self.tag # now write data payload = cool.Record(spec) payload['fileGUID'] = guid print '>== Store object with IOV [', self.since, ',', self.until, '] channel', self.channel, 'and tag', self.tag try: cfolder.storeObject(self.since, self.until, payload, self.channel, self.tag) return except Exception, e: print e print '>== Storing COOL object FAILED' sys.exit(1)
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 = PyCintex.makeClass( 'LArBadChannelState') inst_larBadChannelState = self.class_LArBadChannelState() # Loop over cool channels bStoreNewCoolChannels = False bNewDBCreated = False for coolChan in listKeys: vect_BadChanEntry = PyCintex.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 = PyCintex.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) bStoreNewCoolChannels = True else: continue # Create object based on new LArBadChannelState (via LArBadChannelDBTools python interface) attrListSpec = PyCintex.gbl.coral.AttributeListSpecification() athenaAttrList = PyCintex.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 == False: import os try: dbSave = dbSvc.createDatabase(dbstring) except Exception, 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)
def genDb(self, dbFileName, dbName, params, folderPath, params64={}): # Do checks if self.beginRun is None: raise ParameterDbFillerError( 'Must set begin run number before generating db') if self.endRun is None: raise ParameterDbFillerError( 'Must set end run number before generating db') if len(params) == 0: raise ParameterDbFillerError('No parameters for db ' + dbName) # remove existing db, if any try: os.remove(dbFileName) print("ParameterDbFiller.genDb: Removed db", dbFileName) except Exception: pass # get database service and open database dbSvc = cool.DatabaseSvcFactory.databaseService() # build dbstring - database accessed via physical name dbstring = "sqlite://;schema=" + dbFileName + ";dbname=" + dbName try: db = dbSvc.createDatabase(dbstring) except Exception as e: print('ParameterDbFiller.genDb: Problem creating database', e) sys.exit(-1) print("ParameterDbFiller.genDb: Created database", dbstring) # setup a folder payload specification spec = cool.RecordSpecification() for key in params: spec.extend(key, cool.StorageType.String4k) pass # add in spec for long strings for key in params64: spec.extend(key, cool.StorageType.String64k) # folder meta-data - note for Athena this has a special meaning desc = '<timeStamp>run-event</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' # create the folder - single version # last argument is createParents - if true, automatically creates parent # folders if needed # note this will not work if the database already exists - delete mycool.db first # myfolder=db.createFolder(folderPath, spec, desc, cool.FolderVersioning.SINGLE_VERSION,True) folderSpec = cool.FolderSpecification( cool.FolderVersioning.SINGLE_VERSION, spec) myfolder = db.createFolder(folderPath, folderSpec, desc, True) # now fill in parameters data = cool.Record(spec) for k, v in six.iteritems(params): data[k] = v for k, v in six.iteritems(params64): data[k] = v print("ParameterDbFiller.genDb: Recording parameters", data) # store object with IOV valid from 0-10, channel 3 myfolder.storeObject(self.beginRun, self.endRun, data, 0) print("ParameterDbFiller.genDb: Stored object") # finalize db.closeDatabase() # Try to dump out db as test self.dumpDb(dbstring)
class ParameterDbFiller(object): """ A simple class used to fill SQLite db file with parameters for simulation and/or digitization. """ def __init__(self): object.__init__(self) self.beginRun = None self.endRun = None self.simParams = {} self.digitParams = {} self.digitParams64 = {} return # def setBeginRun(self, beginRun): self.beginRun = beginRun << 32 return def setEndRun(self, endRun): self.endRun = endRun << 32 return def addSimParam(self, name, value): self.simParams[name] = value return def addDigitParam(self, name, value): self.digitParams[name] = value return def addDigitParam64(self, name, value): self.digitParams64[name] = value return def genSimDb(self, dbFileName = None): # Allow to define specific file name, otherwise use customDb = False if dbFileName == None: # Set to default value dbFileName = "SimParams.db" customDb = True # Generate db: args - file name, dbname, params, folder path self.genDb(dbFileName, 'SIMPARAM', self.simParams, '/Simulation/Parameters') def genDigitDb(self, dbFileName = None): # Allow to define specific file name, otherwise use customDb = False if dbFileName == None: # Set to default value dbFileName = "DigitParams.db" customDb = True # Generate db: args - file name, dbname, params, folder path self.genDb(dbFileName, 'DIGPARAM', self.digitParams, '/Digitization/Parameters', self.digitParams64) def genDb(self, dbFileName, dbName, params, folderPath, params64 = {}): # Do checks if self.beginRun == None: raise ParameterDbFillerError, 'Must set begin run number before generating db' if self.endRun == None: raise ParameterDbFillerError, 'Must set end run number before generating db' if len(params) == 0: raise ParameterDbFillerError, 'No parameters for db ' + dbName # remove existing db, if any try: os.remove(dbFileName) print "ParameterDbFiller.genDb: Removed db", dbFileName except: pass # get database service and open database dbSvc=cool.DatabaseSvcFactory.databaseService() # build dbstring - database accessed via physical name dbstring="sqlite://;schema=" + dbFileName + ";dbname=" + dbName try: db=dbSvc.createDatabase(dbstring) except Exception,e: print 'ParameterDbFiller.genDb: Problem creating database',e sys.exit(-1) print "ParameterDbFiller.genDb: Created database",dbstring # setup a folder payload specification spec=cool.RecordSpecification() for key in params: spec.extend(key, cool.StorageType.String4k) pass # add in spec for long strings for key in params64: spec.extend(key, cool.StorageType.String64k) # folder meta-data - note for Athena this has a special meaning desc = '<timeStamp>run-event</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' # create the folder - single version # last argument is createParents - if true, automatically creates parent # folders if needed # note this will not work if the database already exists - delete mycool.db first # myfolder=db.createFolder(folderPath, spec, desc, cool.FolderVersioning.SINGLE_VERSION,True) folderSpec = cool.FolderSpecification(cool.FolderVersioning.SINGLE_VERSION, spec) myfolder = db.createFolder(folderPath, folderSpec, desc, True) # now fill in parameters data = cool.Record(spec) for k, v in params.iteritems(): data[k] = v for k, v in params64.iteritems(): data[k] = v print "ParameterDbFiller.genDb: Recording parameters", data # store object with IOV valid from 0-10, channel 3 myfolder.storeObject(self.beginRun, self.endRun, data, 0) print "ParameterDbFiller.genDb: Stored object" # finalize db.closeDatabase() # Try to dump out db as test self.dumpDb(dbstring)
class mergeStatus(AtlCoolLib.coolTool): def setup(self, args): # set values of non-optional parameters self.destdbstr = str(args[0]) # access to name encoding self.namelookup = DetStatusLib.DetStatusNames() self.folderinfo = [] self.destfolder = '/GLOBAL/DETSTATUS/LBSUMM' self.tag = '' self.truncate = False self.numbers = False def usage(self): "Define additional syntax for options" self._usage1() print 'destdbname' print '--and=<folder> : set folder name to be Anded' print '--override=<folder>:<tag> : set folder and tag name for override' print '--destfolder=<folder> : set destinaton folder (default /GLOBAL/DETSTATUS/LBSUMM' print '--desttag=<tag> : set destination tag' print '--numbers : Transfer NConfig and NWorking from source folders if given' print '--truncate : truncate IOVs which exceed given interval' self._usage2() def procopts(self, opts): "Process additional options" for o, a in opts: if (o == '--and' or o == '--override'): fields = str(a).split(':') folder = fields[0] if len(fields) > 1: tag = fields[1] else: tag = 'HEAD' self.folderinfo += [(folder, tag, (o == '--override'))] if (o == '--destfolder'): self.destfolder = str(a) if (o == '--numbers'): self.numbers = True if (o == '--desttag'): self.tag = str(a) if (o == '--truncate'): self.truncate = True def execute(self): # print "Name is %s" AtlCoolLib.getHostname() # prepare an empty StatusList for each channel statuslists = {} for chan in self.namelookup.allNums(): statuslists[chan] = DetStatusLib.StatusList() # deduce the source database instance name, looking for xyzP200 idx = self.conn.find('P200') if (idx >= 3): dbinst = self.conn[idx - 3:idx + 4] print "Working with database instance %s" % dbinst else: print "Cannot deduce database instance name, assume COMP200" dbinst = 'COMP200' # Extract timestamp information for mapping to run/LB tsconvdb = AtlCoolLib.indirectOpen('COOLONL_TRIGGER/' + dbinst, oracle=self.oracle) # initialize the converter tsToRLB = AtlCoolLib.TimeStampToRLB(tsconvdb, self.since, self.until) tsconvdb.closeDatabase() StartTime = tsToRLB.StartTime EndTime = tsToRLB.EndTime # open auxillary databases for online and DCS info onlinedb = AtlCoolLib.indirectOpen('COOLONL_GLOBAL/' + dbinst, oracle=self.oracle) dcsdb = AtlCoolLib.indirectOpen('COOLOFL_GLOBAL/' + dbinst, oracle=self.oracle) # loop over all 'AND' folders and merge information ngood = 0 nbad = 0 for (afolder, atag, override) in self.folderinfo: print "Process folder %s tag %s override %d" % (afolder, atag, override) try: atsindexed = 0 isonline = 0 if (afolder.find("ONL") != -1): isonline = 1 isdcs = 0 if (afolder.find("DCS") != -1): isdcs = 1 tostart = self.since toend = self.until ifolder = None if (isonline): ifolder = onlinedb.getFolder(afolder) elif (isdcs): ifolder = dcsdb.getFolder(afolder) else: ifolder = self.db.getFolder(afolder) descr = ifolder.description() if (descr.find("<timeStamp>time") != -1): atsindexed = 1 tostart = StartTime toend = EndTime objs = None if (isonline | isdcs): objs = ifolder.browseObjects(tostart, toend, cool.ChannelSelection.all()) else: objs = ifolder.browseObjects(tostart, toend, cool.ChannelSelection.all(), atag) while objs.goToNext(): obj = objs.currentRef() chan = obj.channelId() if (chan in statuslists.keys()): start = obj.since() stop = obj.until() payload = obj.payload() code = payload['Code'] deadfrac = payload['deadFrac'] thrust = payload['Thrust'] if ('NConfig' in payload.keys()): nconfig = payload['NConfig'] nworking = payload['NWorking'] else: nconfig = -1 nworking = -1 if ('Comment' in payload.keys()): comment = payload['Comment'] else: comment = '' #override=False if (atsindexed): start = tsToRLB.getRLB(start, True) stop = tsToRLB.getRLB(stop, False) + 1 statuslists[chan].merge( DetStatusLib.StatusObj(start, stop, code, deadfrac, thrust, nconfig, nworking, comment), override) ngood += 1 else: print "Data found for unexpected channel %i" % chan nbad += 1 except Exception, e: print e print "Problem accessing folder %s" % afolder nbad += 1 print "All folders processed with %i good and %i items of bad data" % ( ngood, nbad) # now compose COOL update # establish write connection writedb = AtlCoolLib.forceOpen(self.destdbstr) if (writedb is None): return try: cfolder = writedb.getFolder(self.destfolder) print "Write data to existing folder %s" % self.destfolder spec = cfolder.payloadSpecification() except Exception, e: print "Creating destination folder %s" % self.destfolder spec = cool.RecordSpecification() spec.extend("Code", cool.StorageType.Int32) spec.extend("deadFrac", cool.StorageType.Float) spec.extend("Thrust", cool.StorageType.Float) if self.numbers: spec.extend("NConfig", cool.StorageType.Int32) spec.extend("NWorking", cool.StorageType.Int32) spec.extend("Comment", cool.StorageType.String255) cfolder = AtlCoolLib.ensureFolder( writedb, self.destfolder, spec, AtlCoolLib.athenaDesc(self.runLumi, 'CondAttrListCollection'), cool.FolderVersioning.MULTI_VERSION)
class LArHVMapDbFiller(object): """ A simple class used to fill SQLite db file with parameters for simulation and/or digitization. """ def __init__(self): object.__init__(self) self.beginTime = None self.endTime = None self.FileName = None self.FolderTag = None self.Params = {} return # def setBegin(self, run, lumi): print " setBegin run,lumi ", run self.beginTime = (long(run) << 32) + long(lumi) print " time ", self.beginTime return def setEnd(self, run, lumi): print "setEnd runmlumi ", run self.endTime = (long(run) << 32) + long(lumi) print " time ", self.endTime return def setFileName(self, fileName): self.FileName = fileName return def setFolderTag(self, folderTag): self.FolderTag = folderTag return def readFile(self): value = '' f = file(self.FileName, 'r') for lines in f: value += lines self.Params['LArHVMap'] = value return def genDb(self): dbFileName = 'HVmap.db' dbName = 'COMP200' folderPath = '/LAR/IdentifierOfl/HVLineToElectrodeMap' # Do checks if self.beginTime == None: raise LArHVMapDbFillerError, 'Must set begin run number before generating db' if self.endTime == None: self.endTime = cool.ValidityKeyMax if self.FileName == None: raise LArHVMapDbFillerError, 'Must give an input file for LArHVToElectrode.data' if self.FolderTag == None: raise LArHVMapDbFillerError, 'Must give a folder tag' self.readFile() if len(self.Params) == 0: raise LArHVMapDbFillerError, 'No parameters for db ' + dbName # remove existing db, if any try: os.remove(dbFileName) print "LArHVMapDbFiller.genDb: Removed db", dbFileName except: pass # get database service and open database dbSvc = cool.DatabaseSvcFactory.databaseService() # build dbstring - database accessed via physical name dbstring = "sqlite://;schema=" + dbFileName + ";dbname=" + dbName try: db = dbSvc.createDatabase(dbstring) except Exception, e: print 'LArHVMapDbFiller.genDb: Problem creating database', e sys.exit(-1) print "LArHVMapDbFiller.genDb: Created database", dbstring # setup a folder payload specification spec = cool.RecordSpecification() for key in self.Params: spec.extend(key, cool.StorageType.String16M) # folder meta-data - note for Athena this has a special meaning desc = '<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName>' # create the folder - single version # last argument is createParents - if true, automatically creates parent # folders if needed # note this will not work if the database already exists - delete mycool.db first myfolder = db.createFolder(folderPath, spec, desc, cool.FolderVersioning.MULTI_VERSION, True) # now fill in simlation parameters data = cool.Record(spec) for k, v in self.Params.iteritems(): data[k] = v print "LArHVMapDbFiller.genDb: Recording parameters", data # store object with IOV valid from 0-10, channel 3 myfolder.storeObject(self.beginTime, self.endTime, data, 0, self.FolderTag) print "LArHVMapDbFiller.genDb: Stored object" # finalize db.closeDatabase() # Try to dump out db as test self.dumpDb(dbstring)
class Databases(object): """ Databases helper class. Used as a singleton. (don't instantiate) Specifies abbreviations for database connection strings and folders """ FOLDERS = { "DQMFONL": "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/DQMFONL", "DQMFONLLB": "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/DQMFONLLB", "SHIFTONL": "COOLONL_GLOBAL::/GLOBAL/DETSTATUS/SHIFTONL", "DQMFOFL": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DQMFOFL", "DCSOFL": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DCSOFL", "DQCALCOFL": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DQCALCOFL", "SHIFTOFL": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/SHIFTOFL", "LBSUMM": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/LBSUMM", "VIRTUALFLAGS": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/VIRTUALFLAGS", "DEFECTS": "COOLOFL_GLOBAL::/GLOBAL/DETSTATUS/DEFECTS", "SOR_Params": "COOLONL_TDAQ::/TDAQ/RunCtrl/SOR_Params", "EOR_Params": "COOLONL_TDAQ::/TDAQ/RunCtrl/EOR_Params", "SOR": "COOLONL_TDAQ::/TDAQ/RunCtrl/SOR", "EOR": "COOLONL_TDAQ::/TDAQ/RunCtrl/EOR", "LBLB": "COOLONL_TRIGGER::/TRIGGER/LUMI/LBLB", "LBTIME": "COOLONL_TRIGGER::/TRIGGER/LUMI/LBTIME", "LBLESTONL": "COOLONL_TRIGGER::/TRIGGER/LUMI/LBLESTONL", "LVL1COUNTERS": "COOLONL_TRIGGER::/TRIGGER/LUMI/LVL1COUNTERS", "HLTCOUNTERS": "COOLOFL_TRIGGER::/TRIGGER/LUMI/HLTCOUNTERS", "HLT/Menu": "COOLONL_TRIGGER::/TRIGGER/HLT/Menu", "LVL1/Menu": "COOLONL_TRIGGER::/TRIGGER/LVL1/Menu", "Prescales": "COOLONL_TRIGGER::/TRIGGER/LVL1/Prescales", } @classmethod def resolve_folder_string(cls, folder_name, db_override=None): """ Resolves a simplified folder URI. Examples: folder_name == "SHIFTOFL" will give a connection to COOLOFL_GLOBAL/COMP200 folder /GLOBAL/DETSTATUS/SHIFTOFL folder_name == "test.db::SHIFTOFL" will give a connection to an sqlite database test.db Priority: * Database specified in db_override * Database specified in `folder_name` * Database specified in cls.FOLDERS[folder_name] """ res_database = db_override # First check - is a database specified in the folder name? if "::" in folder_name: assert folder_name.count("::") == 1, "Bad folder format" database, folder_name = folder_name.split("::") # If res_database hasn't already been set, do so res_database = database if not res_database else res_database if folder_name in cls.FOLDERS: database, res_folder = cls.FOLDERS[folder_name].split("::") res_database = database if not res_database else res_database else: res_folder = folder_name return res_database, res_folder @classmethod def get_folder(cls, folder_name, db_override=None, read_only=True, create_function=None, also_db=False): """ Retrieve a folder. The `db_override` parameter allows over-riding the database which comes from the folder string. Parameters: `folder_name` : Folder name or alias to load `db_override` : If specified, causes an alternate database string to be used. `read_only` : Specifies if a read-only database connection should be used. `create_function` : If specified, function to be called in case the folder doesn't exist. It is passed the database connection. `also_db` : Make the return value (db, folder) """ if read_only: assert not create_function, "`read_only` specified with `create`" database, folder = cls.resolve_folder_string(folder_name, db_override) assert database, ("Unable to resolve database for (%s, %s)" % (folder_name, db_override)) create = bool(create_function) db = cls.get_instance(database, read_only, create) try: cool_folder = db.getFolder(folder) except Exception as error: log.debug('HELP! %s' % error.args) args = str(error.args[0] if not isinstance(error.args, basestring) else error.args) log.debug('THIS IS %s' % type(args)) log.debug('Value of boolean: %s' % ("not found" in args)) if not ("cannot be established" in args or "not found" in args): log.exception("Unknown error encountered whilst opening " "database connection to '%s'" % database) raise if not create_function: log.exception("Database does not exist, `create_function` not " "specified") raise cool_folder = create_function(db) if also_db: return db, cool_folder return cool_folder @classmethod def resolve_db_string(cls, db_string, read_only=True): """ Take a database string - if it looks like a filename ending in ".db" then assume it is a sqlite database with that name. If the `db_string` is prepended with "WRITE|" then a writable connection is requested. If the db_string doesn't contain a "/", then "/" + DEFAULT_DBNAME is appended. """ if "://" in db_string: # Assume that the string is already resolved return db_string, read_only if db_string.startswith("WRITE|"): assert db_string.count("|") == 1, "Bad db_string format" db_string = db_string.split("|")[1] read_only = False sqlite_regex = re.compile( r"(?P<filename>.*?\.db)(?:/?(?P<dbname>[^/]+))?$") matched = sqlite_regex.match(db_string) if matched: filename, dbname = matched.groups() dbname = DEFAULT_DBNAME if not dbname else dbname db_string = "sqlite://schema=%s;dbname=%s" % (filename, dbname) else: if "/" not in db_string: return db_string + "/" + DEFAULT_DBNAME, read_only return db_string, read_only @classmethod def get_instance(cls, db_string, read_only=True, create=False): """ Open a database connection """ res_db_string, read_only = cls.resolve_db_string(db_string, read_only) try: prev_stdout = sys.stdout sys.stdout = StringIO() try: connection = indirectOpen(res_db_string, readOnly=read_only, oracle=True) finally: sys.stdout = prev_stdout except Exception as e: if "The database does not exist" in e.args[0] and not create: log.info("Failed trying to connect to '%s'", res_db_string) raise from PyCool import cool dbService = cool.DatabaseSvcFactory.databaseService() connection = dbService.createDatabase(res_db_string) except: print sys.exc_info()[0] raise return connection @classmethod def build_folder(cls, db, folder_name, multiversion, record): """ Create `folder_name` on database instance `db`, with recordspecification `record`. Also creates folderset to which folder_name belongs if necessary. """ from PyCool import cool folderset_path = dirname(folder_name) try: folder_set = db.getFolderSet(folderset_path) except Exception, error: caught_error = "Folder set %s not found" % folderset_path if caught_error not in error.args[0]: raise log.debug("Folderset doesn't exist - creating it.") db.createFolderSet(folderset_path, "", True) if not isinstance(record, cool.RecordSpecification): record_spec = cool.RecordSpecification() for field in record: record_spec.extend(*field) else: record_spec = record FV = cool.FolderVersioning versioning = FV.MULTI_VERSION if multiversion else FV.SINGLE_VERSION folder_spec = cool.FolderSpecification(versioning, record_spec) folder = db.createFolder(folder_name, folder_spec) payload = cool.Record(record_spec) return folder, payload
dbSvc=cool.DatabaseSvcFactory.databaseService() # database accessed via physical name dbstring='sqlite://;schema=RPCDQMFOFFLINE.db;dbname=RPC_DQA' if os.access('RPCDQMFOFFLINE.db', os.R_OK): try: os.unlink('RPCDQMFOFFLINE.db') except Exception, e: print 'Unable to remove existing db file, reason', e try: db=dbSvc.createDatabase(dbstring) except Exception,e: print 'Problem creating database',e return print "Created database",dbstring spec2=cool.RecordSpecification() spec2.extend("recEta",cool.StorageType.String4k) spec2.extend("detEta",cool.StorageType.String4k) spec2.extend("recPhi1",cool.StorageType.String4k) spec2.extend("recPhi2",cool.StorageType.String4k) spec2.extend("detPhi1",cool.StorageType.String4k) spec2.extend("detPhi2",cool.StorageType.String4k) # folder meta-data - note for Athena this has a special meaning desc="<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type=\"71\" clid=\"1238547719\" /></addrHeader><typeName>CondAttrListCollection</typeName>" # create the folder - single version # last argument is createParents - if true, automatically creates parent # folders if needed # note this will not work if the database already exists - delete mycool.db first # Deprecated/dropped: myfolder=db.createFolder('/OFFLINE/OFFLINE_DQMF',spec2,desc,cool.FolderVersioning.MULTI_VERSION,True) folderSpec=cool.FolderSpecification(cool.FolderVersioning.MULTI_VERSION, spec2)
dbSvc = cool.DatabaseSvcFactory.databaseService() # database accessed via physical name dbstring = "sqlite://;schema=%s;dbname=%s" % (dbfile, dbname) try: db = dbSvc.createDatabase(dbstring) except Exception, e: print 'Problem creating database', e sys.exit(-1) print "Created database", dbstring # ----------------------------------------------------------------------- # # setup a folder # ----------------------------------------------------------------------- # #spec=cool.RecordSpecification() recspec = cool.RecordSpecification() recspec.extend("version", cool.StorageType.String4k) recspec.extend("syserrors", cool.StorageType.String4k) spec = cool.FolderSpecification(cool.FolderVersioning.MULTI_VERSION, recspec, True) #spec.extend(fdspec,cool.StorageType.String16M) # folder meta-data - note for Athena this has a special meaning desc = '<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader><typeName>CondAttrListCollection</typeName>' ####<timeStamp>time</timeStamp><addrHeader><address_header service_type="71" clid="40774348" /></addrHeader><typeName>AthenaAttributeList</typeName> # create the folder - single version # last argument is createParents - if true, automatically creates parent folders if needed # note this will not work if the database already exists - delete mycool.db first
class LArDBFolderBrowser_MissingFEBs(): def __init__(self, nspace_LArBadChannelDBTools, class_LArBadChanBitPacking, class_LArBadChannel, class_HWIdentifier, onLineID, larCablingSvc): self.nspace_LArBadChannelDBTools = nspace_LArBadChannelDBTools self.class_LArBadChanBitPacking = class_LArBadChanBitPacking self.class_LArBadChannel = class_LArBadChannel self.class_HWIdentifier = class_HWIdentifier self.onlineID = onLineID self.larCablingSvc = larCablingSvc self.dict_vectMissingFebHWid = {} self.dict_vectMissingFebHWid_Status = {} self.dict_vectMissingFebHWid_Init = {} return def MissingFeb_SetBadChannelDataFromPayload(self, coolChan, payload): # Get components of payload object channelSize = payload['ChannelSize'] endianness = payload['Endianness'] version = payload['Version'] blob = payload['Blob'] # Decode blob content vect_MissingFebHWid = self.nspace_LArBadChannelDBTools.decodeFebBlob( blob, channelSize, endianness, version, self.nspace_LArBadChannelDBTools.getDefaultMsgStream()) print vect_MissingFebHWid.size() for s in vect_MissingFebHWid: print s, print "" # Add entry in dictionnary sChannelKey = coolChan if not self.dict_vectMissingFebHWid.has_key(sChannelKey): self.dict_vectMissingFebHWid[sChannelKey] = {} # Transform vect_BadChanNetry into python dictionnary sChannelDict, sChannelDict_Status = self.MissingFeb_TransformEntryIntoDictionnary( vect_MissingFebHWid) self.dict_vectMissingFebHWid[sChannelKey] = {} self.dict_vectMissingFebHWid_Init[sChannelKey] = {} for key in sChannelDict.keys(): self.dict_vectMissingFebHWid[sChannelKey][key] = sChannelDict[key] self.dict_vectMissingFebHWid_Init[sChannelKey][key] = sChannelDict[ key] self.dict_vectMissingFebHWid_Status[sChannelKey] = sChannelDict_Status return ("None") def MissingFeb_DisplayMissingFeb(self, coolChan): """ """ iChanCmpt = 0 listHWidKeys = [ x for x in self.dict_vectMissingFebHWid[coolChan].keys() ] listHWidKeys.sort() print "" for sHWid in listHWidKeys: if self.dict_vectMissingFebHWid_Init[coolChan].has_key(sHWid): sChanName, sStatus, sValueInit = self.dict_vectMissingFebHWid_Init[ coolChan][sHWid] sPrefix = "" if self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] != STATUS_INIT: sPrefix = "->" self.MissingFeb_DisplayMissingFebLine(sPrefix, iChanCmpt, sHWid, sChanName, sStatus, "") if self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] != STATUS_INIT: sChanName, sStatus, sValueInit = self.dict_vectMissingFebHWid[ coolChan][sHWid] channelStatus = self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] self.MissingFeb_DisplayMissingFebLine(channelStatus, iChanCmpt, sHWid, sChanName, sStatus, "") iChanCmpt += 1 def MissingFeb_DisplayMissingFebLine(self, sMessage, iChanCmpt, sHWid, sChanName, sStatusValue, sValueInit): obj_HWid = self.class_HWIdentifier() obj_HWid.set(sHWid) cblSvc_id = self.larCablingSvc.cnvToIdentifier(obj_HWid) cblSvc_string = self.onlineID.print_to_string(cblSvc_id) barrel_ec = self.onlineID.barrel_ec(obj_HWid) pos_neg = self.onlineID.pos_neg(obj_HWid) feedthrough = self.onlineID.feedthrough(obj_HWid) slot = self.onlineID.slot(obj_HWid) channel = self.onlineID.channel(obj_HWid) if sMessage == "": print " %5d : %-10s %1d %1d %2d %2d %3d %40s %s " % ( iChanCmpt + 1, obj_HWid.getString(), barrel_ec, pos_neg, feedthrough, slot, channel, sChanName, sStatusValue) else: print "%3s %5d : %-10s %1d %1d %2d %2d %3d %40s %s %s" % ( sMessage, iChanCmpt + 1, obj_HWid.getString(), barrel_ec, pos_neg, feedthrough, slot, channel, sChanName, sStatusValue, sValueInit) def MissingFeb_ShowMissingFebCorrectionsSummary(self, coolChan): listHWidKeys = [ x for x in self.dict_vectMissingFebHWid[coolChan].keys() ] listHWidKeys.sort() print "" print "Correction summary : " iNbCorrection = 0 for index, sHWid in enumerate(listHWidKeys): if self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] != STATUS_INIT: sChanName, badChan_word, sValueInit = self.dict_vectMissingFebHWid[ coolChan][sHWid] channelStatus = self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] self.MissingFeb_DisplayMissingFebLine(channelStatus, index, sHWid, sChanName, badChan_word, "") iNbCorrection += 1 if iNbCorrection == 0: print "-" def MissingFeb_TransformEntryIntoDictionnary(self, vMissingFEBHWid): """ Transform the missing FEB decoded from blob object into a python dictionnary """ print "--------------------------- Blob SIZE : ", vMissingFEBHWid.size( ) iNbMissingFEB = vMissingFEBHWid.size() sChannelDict = {} sChannelDict_Status = {} for i in range(0, iNbMissingFEB): obj_HWid = vMissingFEBHWid.at(i) sHexaString = obj_HWid.getString() sChannelName = self.onlineID.channel_name(vMissingFEBHWid.at(i)) sInitialValues = sHexaString + " " + STATUS_MISSING_FEB sChannelDict[sHexaString] = (sChannelName, STATUS_MISSING_FEB, sInitialValues) sChannelDict_Status[sHexaString] = STATUS_INIT return (sChannelDict, sChannelDict_Status) def MissingFeb_ModifyMissingFeb(self, coolChan): listHWidKeys = [ x for x in self.dict_vectMissingFebHWid[coolChan].keys() ] listHWidKeys.sort() iNbBadChannel = len(self.dict_vectMissingFebHWid[coolChan].keys()) bEndOfCorrection = False while not bEndOfCorrection: print "" print ".. To add a missing feb : enter barrel_ec pos_neg feedthrough slot " print ".. To remove a missing feb : enter -(channel index) " print ".. Other : s (summary) / r (refresh list) / a (abort) / q (save and quit) .. > ", tty = open("/dev/tty", "r+") rep = tty.readline() rep = rep.strip() bReadableAnswer = True barrel_ec = -1 pos_neg = -1 feedthrough = -1 slot = -1 channel = -1 iSelectedIndex = 0 sTxtAnswer = "" iCombinationAnswer = 0 try: barrel_ec, pos_neg, feedthrough, slot = rep.split(' ') channel = 0 bReadableAnswer = True iCombinationAnswer = 1 except: if rep == "a": sTxtAnswer = "abort" elif rep == "r": sTxtAnswer = "refresh" elif rep == "s": sTxtAnswer = "summary" elif rep == "q": sTxtAnswer = "save-quit" else: try: iSelection = int(rep) if iSelection in range(1, iNbBadChannel + 1): iSelectedIndex = iSelection if iSelection in range(-iNbBadChannel - 1, 0): iSelectedIndex = iSelection if iSelectedIndex == -99999: bReadableAnswer = False except: iSelectedIndex = 0 bReadableAnswer = False continue if bReadableAnswer == False: print "could not decode answer... " bEndOfCorrection = False continue # Abort answer if sTxtAnswer == "abort": iAbortConfirmation = LArBadChannelBrowserTools.YesNoQuestion( "Are you sure you want to quit ? ") if iAbortConfirmation == 1: return 'a' bEndOfCorrection = False # Refresh answer if sTxtAnswer == "refresh": self.MissingFeb_DisplayMissingFeb(coolChan) bEndOfCorrection = False # Summary answer if sTxtAnswer == "summary": self.MissingFeb_ShowMissingFebCorrectionsSummary(coolChan) bEndOfCorrection = False # Refresh answer if sTxtAnswer == "save-quit": return 'q' # Channel selected by negative index => to remove if iSelectedIndex < 0: sHWid = listHWidKeys[-iSelectedIndex - 1] sChanName, sFebstatus, sValueInit = self.dict_vectMissingFebHWid[ coolChan][sHWid] iDeleteConfirmation = LArBadChannelBrowserTools.YesNoQuestion( "Are you sure you want to delete " + sChanName + " ? ") if iDeleteConfirmation == 1: self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] = STATUS_REMOVED self.dict_vectMissingFebHWid[coolChan][sHWid] = ( sChanName, STATUS_NOT_MISSING_FEB, sValueInit) bEndOfCorrection = False # Channel selected by index or parameters if iSelectedIndex > 0 or iCombinationAnswer == 1: if iSelectedIndex > 0: sHWid = listHWidKeys[iSelectedIndex - 1] sChanName, sFebStatus, sValueInit = self.dict_vectMissingFebHWid[ coolChan][sHWid] else: iRes, sHWid, sChanName, sFebStatus = self.MissingFeb_GetChannelHWIdentifierAndStatus( barrel_ec, pos_neg, feedthrough, slot, channel) if iRes == 0: print "FEB already defined as missing" sValueInit = self.dict_vectMissingFebHWid[coolChan][ sHWid][2] else: sValueInit = "None" self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] = STATUS_NEW self.dict_vectMissingFebHWid[coolChan][sHWid] = ( sChanName, STATUS_MISSING_FEB, sValueInit) bEndOfCorrection = False # Display correction summary self.MissingFeb_ShowMissingFebCorrectionsSummary(coolChan) return StatusCode.Success def MissingFeb_GetChannelHWIdentifierAndStatus(self, barrel_ec, pos_neg, feedthrough, slot, channel): """ Get channel HW identifier and its status """ sid = self.onlineID.channel_Id(int(barrel_ec), int(pos_neg), int(feedthrough), int(slot), int(channel)) print str(barrel_ec) + " " + str(pos_neg) + " " + str( feedthrough) + " " + str(slot) + " " + str( channel) + " => ", sid.getString() # Check if HW identifier is valid bValidWHidentifier = False if self.onlineID.isEMBchannel(sid): bValidWHidentifier = True if self.onlineID.isEMECchannel(sid): bValidWHidentifier = True if self.onlineID.isHECchannel(sid): bValidWHidentifier = True if self.onlineID.isFCALchannel(sid): bValidWHidentifier = True if bValidWHidentifier == False: return (-1, sid.getString(), "", 0) for key in self.dict_vectMissingFebHWid.keys(): for sHWid in self.dict_vectMissingFebHWid[key].keys(): sChannelName, sFebStatus, x = self.dict_vectMissingFebHWid[ key][sHWid] if sid.getString() == sHWid: return (0, sid.getString(), sChannelName, sFebStatus) return (1, sid.getString(), sChannelName, STATUS_MISSING_FEB) def MissingFeb_SaveMissingFebCorrectionsToDatabase(self, dbstring, dbSvc, dbFolderName, selectedTag): listKeys = self.dict_vectMissingFebHWid.keys() listKeys.sort() # Loop over cool channels bStoreNewCoolChannels = False bNewDBCreated = False vect_MissingFebHWid = PyCintex.gbl.std.vector('HWIdentifier')() coolChan = 0 listHWidKeys = [ x for x in self.dict_vectMissingFebHWid[coolChan].keys() ] listHWidKeys.sort() iNbCorrection = 0 for key in listHWidKeys: sHWid = key if self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] == STATUS_INIT: sStatusFeb = self.dict_vectMissingFebHWid_Init[coolChan][ sHWid][1] elif self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] == STATUS_MODIFIED or self.dict_vectMissingFebHWid_Status[ coolChan][sHWid] == STATUS_NEW: iNbCorrection += 1 sStatusFeb = self.dict_vectMissingFebHWid[coolChan][sHWid][1] elif self.dict_vectMissingFebHWid_Status[coolChan][ sHWid] == STATUS_REMOVED: iNbCorrection += 1 continue obj_HWid = self.class_HWIdentifier() obj_HWid.set(sHWid) vect_MissingFebHWid.push_back(obj_HWid) # if correction were made => store MissingFebHWid vector if iNbCorrection > 0: bStoreNewCoolChannels = True else: print "No correcton to save" return # Create object based on new LArBadChannelState (via LArBadChannelDBTools python interface) attrListSpec = PyCintex.gbl.coral.AttributeListSpecification() athenaAttrList = PyCintex.gbl.AthenaAttributeList() attrListSpec = self.nspace_LArBadChannelDBTools.createCoolSpec() athenaAttrList = self.nspace_LArBadChannelDBTools.createFebPayload( vect_MissingFebHWid) # new DB creation import os try: dbSave = dbSvc.createDatabase(dbstring) except Exception, 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.MULTI_VERSION, True) import string IOVBeginEnd = ["90", "9999999"] beginRun = string.atoi(IOVBeginEnd[0]) << 32 endRun = string.atoi(IOVBeginEnd[1]) << 32 # 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 dbSave.closeDatabase()