← Back to branch summary

~vpec/maus/tof_calib_read

« back to all changes in this revision

Viewing changes to workers/WriteDB.py

  • Committer: tunnell
  • Date: 2010-09-20 10:52:02 UTC
  • Revision ID: tunnell@itchy-20100920105202-ce4w9jm59zvgnsxq
moving stuff from tucs

Show diffs side-by-side

added added

removed removed

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