1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
|
# Author: Christopher Tunnell <tunnell@hep.uchicago.edu>
#
# For DB constants
#
# March 04, 2009
#
# July 16, 2009 : Adapted to LASER by Seb Viret <viret@in2p3.fr>
#
from src.ReadGenericCalibration import *
from src.region import *
import os
from array import array
# For reading from DB
from TileCalibBlobPython import TileCalibTools, TileBchTools
from TileCalibBlobPython.TileCalibTools import MINRUN, MINLBK, MAXRUN, MAXLBK, LASPARTCHAN
from TileCalibBlobObjs.Classes import *
# For turning off annoying logging
import logging
from TileCalibBlobPython.TileCalibLogger import TileCalibLogger, getLogger
class WriteDB(ReadGenericCalibration):
"write out a tileSqlite.db file with database constants"
def get_latest_run(self):
"""
Usage: get_latest_run()
Arguments:
None
Returns:
* integer indicating the latest run
"""
f = urllib.urlopen('http://atlas-service-db-runlist.web.cern.ch/atlas-service-db-runlist/cgi-bin/latestRun.py')
rv = f.read()
f.close()
return int(rv)
def __init__(self, runType = 'CIS', offline_tag = 'HLT-UPD1-00',version = 1):
self.runType = runType
#
# S.Viret (24/08/2009) :
# 'version' is the version number of the offline database you want to use
# This is usually 1 but it appears that in some cases (cesium and LASER
# references) it's 2.
#
#
# Here things are done depending on runType
#
if runType == 'CIS':
offline_tag = 'TileOfl0%dCalibCisFitLin-%s' % (version,offline_tag)
self.offline_folder = TileCalibTools.getTilePrefix()+"CALIB/CIS/FIT/LIN"
self.offline_tag = offline_tag
self.online_folder = TileCalibTools.getTilePrefix(ofl=False)+"CALIB/CIS/LIN"
self.online_tag = ""
elif runType == 'Las':
self.offline_tag = 'TileOfl0%dCalibLasLin-%s' % (version,offline_tag)
self.offline_tag_F = 'TileOfl0%dCalibLasFiber-%s' % (version,offline_tag)
self.offline_folder = TileCalibTools.getTilePrefix()+"CALIB/LAS/LIN"
self.offline_folder_F = TileCalibTools.getTilePrefix()+"CALIB/LAS/FIBER"
self.online_folder = TileCalibTools.getTilePrefix(ofl=False)+"CALIB/LAS/LIN"
self.online_tag = ""
elif runType == 'Las_REF' or runType=='cesium':
offline_tag = 'TileOfl0%dCalibCes-%s' % (version,offline_tag)
self.offline_folder = '/TILE/OFL0%d/CALIB/CES' % version
self.offline_tag = offline_tag
self.online_folder = TileCalibTools.getTilePrefix(ofl=False)+"CALIB/CES"
self.online_tag = ""
else:
print 'WriteDB: Failed to initialize'
return
# use the latest run number as starting point (common to everyone)
self.offline_iov = (self.get_latest_run(), 0)
self.online_iov = (self.get_latest_run(), 0)
PyCintex.makeClass('std::vector<float>')
PyCintex.makeClass('std::vector<unsigned int>')
#
# Here we instantiate the different parameters
#
def ProcessStart(self):
# open DB connection to sqlite file
self.db = TileCalibTools.openDb('SQLITE', 'COMP200', 'UPDATE')
self.blobWriterOnline = TileCalibTools.TileBlobWriter(self.db,self.online_folder, 'Flt', False)
self.blobWriterOffline = TileCalibTools.TileBlobWriter(self.db,self.offline_folder, 'Flt')
if self.runType == 'Las': # For fiber and partition stuff
self.blobWriterOffline_F = TileCalibTools.TileBlobWriter(self.db,self.offline_folder_F, 'Flt')
if self.runType == 'Las_REF' or self.runType == 'cesium': # For recovering Cesium reference values
#self.db_REF = TileCalibTools.openDb('ORACLE', 'COMP200', 'READONLY')
self.db_REF = TileCalibTools.openDbConn('COOLOFL_TILE/COMP200', 'READONLY')
self.blobReader = TileCalibTools.TileBlobReader(self.db_REF, self.offline_folder, self.offline_tag)
util = PyCintex.gbl.TileCalibUtils()
#
# Once again things are done depending on runType
#
if self.runType == 'CIS':
loGainDef=(1023./800.)
hiGainDef=(64.*1023./800.)
loGainDefVec = PyCintex.gbl.std.vector('float')()
loGainDefVec.push_back(loGainDef)
hiGainDefVec = PyCintex.gbl.std.vector('float')()
hiGainDefVec.push_back(hiGainDef)
defVec = PyCintex.gbl.std.vector('std::vector<float>')()
defVec.push_back(loGainDefVec)
defVec.push_back(hiGainDefVec)
elif self.runType == 'Las':
lohiGainDefVec = PyCintex.gbl.std.vector('float')()
lohiGainDefVec.push_back(1.)
defVec = PyCintex.gbl.std.vector('std::vector<float>')()
defVec.push_back(lohiGainDefVec)
defVec.push_back(lohiGainDefVec)
elif self.runType == 'Las_REF' or self.runType == 'cesium':
default = PyCintex.gbl.std.vector('float')()
default.push_back( 1.) # cesium constant
default.push_back( -1.) # laser default value
default.push_back(700.) # reference HV
default.push_back( 20.) # reference temperature (same for all channels)
defVec = PyCintex.gbl.std.vector('std::vector<float>')()
defVec.push_back(default)
defVec.push_back(default)
# Then we initialize everything
for ros in xrange(util.max_ros()):
for drawer in xrange(util.getMaxDrawer(ros)):
flt = self.blobWriterOffline.getDrawer(ros,drawer)
flt.init(defVec, 48, 1)
if self.runType == 'Las':
flt = self.blobWriterOffline_F.getDrawer(ros,drawer)
flt.init(defVec, 48, 1)
flt = self.blobWriterOnline.getDrawer(ros,drawer)
flt.init(defVec, 48, 1)
def ProcessStop(self):
# iov until is the end of the interval of validity, so infinity here
iovUntil = (MAXRUN,MAXLBK)
author = "%s" % os.getlogin()
self.blobWriterOnline.setComment(author, "TUCS %s" % (" ".join(sys.argv)))
self.blobWriterOnline.register(self.online_iov, iovUntil, self.online_tag)
self.blobWriterOffline.setComment(author, "TUCS %s" % (" ".join(sys.argv)))
self.blobWriterOffline.register(self.offline_iov, iovUntil, self.offline_tag)
if self.runType == 'Las':
self.blobWriterOffline_F.setComment(author, "TUCS %s" % (" ".join(sys.argv)))
self.blobWriterOffline_F.register(self.offline_iov, iovUntil, self.offline_tag_F)
if self.runType == 'Las_REF' or self.runType == 'cesium':
self.db_REF.closeDatabase()
self.db.closeDatabase()
#
# Here we do the writing
#
def ProcessRegion(self, region):
if 'gain' not in region.GetHash():
return
# First the LASER case
if self.runType == 'Las' or self.runType == 'Las_REF':
part, mod, chan, gain = region.GetNumber()
for event in region.GetEvents():
# Case 1: relative variation
if self.runType == 'Las' and event.data.has_key('calibration'):
#print 'region updated: ', event.data['region'], event.data['calibration']
drawer = self.blobWriterOffline.getDrawer(part, mod-1)
drawer_F = self.blobWriterOffline_F.getDrawer(part, mod-1)
# Then we update if there is a new value (coefficients are in %, so we put in correct format)
# First update PMT variation
drawer.setData(int(chan), int(gain), 0, float(1+event.data['deviation']/100))
# Then update Fiber variation (optional)
if event.data.has_key('fiber_var'):
drawer_F.setData(int(chan), int(gain), 0, float(1+event.data['fiber_var']/100))
# Finally update Partition variation (optional)
if event.data.has_key('part_var'):
drawer_F.setData(LASPARTCHAN, int(gain), 0, float(1+event.data['part_var']/100))
# Case 2: reference values
if self.runType == 'Las_REF':
drawer_R = self.blobReader.getDrawer(part, mod-1, (event.runNumber, 0))
if event.data.has_key('calibration_db'): # Channel has a relevant value, store it
reference = event.data['calibration']
drawer = self.blobWriterOffline.getDrawer(part, mod-1)
drawer.setData(int(chan), int(gain), 0, drawer_R.getData(chan, gain, 0))
drawer.setData(int(chan), int(gain), 1, float(reference))
drawer.setData(int(chan), int(gain), 2, drawer_R.getData(chan, gain, 2))
drawer.setData(int(chan), int(gain), 3, drawer_R.getData(chan, gain, 3))
elif event.data.has_key('is_OK'):
print 'No data, set default for region', region.GetHash()
drawer = self.blobWriterOffline.getDrawer(part, mod-1)
drawer.setData(int(chan), int(gain), 0, drawer_R.getData(chan, gain, 0))
drawer.setData(int(chan), int(gain), 1, float(-1))
drawer.setData(int(chan), int(gain), 2, drawer_R.getData(chan, gain, 2))
drawer.setData(int(chan), int(gain), 3, drawer_R.getData(chan, gain, 3))
# Then the other cases
elif self.runType=='cesium':
part, mod, chan, gain = region.GetNumber()
if gain!=0: return
drawer = self.blobWriterOffline.getDrawer(part, mod-1)
if not region.GetEvents():
# region is empty, writing defaults
self.writeCsDef(region,drawer,chan,gain)
# write defaults if
writeDef=True
for event in region.GetEvents():
if event.runType==self.runType:
if event.data.has_key('calibration') and event.data['calibration']:
# channel was calibrated
writeDef=False
drawer.setData(int(chan), int(gain), 0, event.data['calibration'])
drawer.setData(int(chan), int(gain), 1, -1.0)
drawer.setData(int(chan), int(gain), 2, event.data['HV'])
drawer.setData(int(chan), int(gain), 3, event.data['temp'])
if writeDef:
self.writeCsDef(region,drawer,chan,gain)
else:
x, y, z, w = region.GetNumber()
calibration = None
for event in region.GetEvents():
if event.runType == self.runType:
if event.data.has_key('calibratableRegion') and event.data['calibratableRegion']:
if event.data.has_key('mean'):
calibration = event.data['mean']
#print 'yo'
blobObjVersion = 1
if calibration:
print 'region updated: ', region.GetHash(), calibration
modBlob = self.blobWriterOnline.getDrawer(int(x), int(y-1))
modBlob.setData(int(z), int(w), 0, float(calibration))
modBlob = self.blobWriterOffline.getDrawer(int(x), int(y-1))
modBlob.setData(int(z), int(w), int(0), float(calibration))
else:
default_val = (64.*1023./800.) # highgain
if 'low' in region.GetHash():
default_val = (1023./800.)
print 'region default: ', region.GetHash(), default_val
modBlob = self.blobWriterOnline.getDrawer(int(x), int(y-1))
modBlob.setData(int(z), int(w), 0, float(default_val))
modBlob = self.blobWriterOffline.getDrawer(int(x), int(y-1))
modBlob.setData(int(z), int(w), int(0), float(default_val))
def writeCsDef(self,region,drawer,chan,gain):
# writing defaults
calibration=1.0
tower=region.GetParent('physical').GetParent('physical')
if 'sD' in tower.GetHash():
calibration=1.2
if 'sE' in tower.GetHash():
calibration=1.5
drawer.setData(int(chan), int(gain), 0, calibration)
drawer.setData(int(chan), int(gain), 1, -1.0)
drawer.setData(int(chan), int(gain), 2, 700.0 )
drawer.setData(int(chan), int(gain), 3, 20.0)
|