ATLAS Offline Software
Loading...
Searching...
No Matches
TileCalibDefaultWriter.py
Go to the documentation of this file.
1#!/bin/env python
2
3# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
4# TileCalibDefaultWriter.py
5# Nils Gollub <nils.gollub@cern.ch>, 2007-11-23
6#
7# Lukas Pribyl <lukas.pribyl@cern.ch>, 2008-07-09
8# Guilherme Lima <jlima@cernNOSPAM.ch>, 2013-07-30 - changes to default Cs conditions
9# Yuri Smirnov <iouri.smirnov@cern.ch>, 2014-12-24 - PyCintex->cppyy for ROOT6
10
11"""
12Python helper module for initializing db with default values
13Note the COOL channels for default values:
14- global default = channel 0
15- default for LBA = channel 4
16- default for LBC = channel 8
17- default for EBA = channel 12
18- default for EBA = channel 16
19
20All offline constants are written to OFL02 folder
21In the COOLONL_TILE schema and COMP200 DB
22some constants exist also in OFL01 folder
23To write constants to this folder special prefix can be used:
24
25self.__tilePrefixOfl1
26
27"""
28
29import cppyy
30
31from TileCalibBlobPython import TileCalibTools
32from TileCalibBlobPython.TileCalibTools import MINRUN, MINLBK, MAXRUN, MAXLBK, LASPARTCHAN
33from TileCalibBlobPython.TileCalibLogger import TileCalibLogger
34from TileCalibBlobObjs.Classes import TileCalibUtils, TileBchDecoder
35import os
36
37#=== path to files with default values
38pathDef = "/afs/cern.ch/atlas/software/builds/AtlasConditions/latest/TileCalorimeter/TileConditions/share/"
39
40#
41#______________________________________________________________________
42class TileCalibDefaultWriter(TileCalibLogger):
43 """
44 This class provides methods to write default values for the various
45 TileCal COOL folders.
46 """
47 __slots__ = ["__author","__db","__tilePrefixOfl1","__tilePrefixOfl","__tilePrefixOnl"]
48
49 #____________________________________________________________________
50 def __init__(self, db):
51 """
52 Input:
53 - db : db should be an open database connection
54 - globalTag: A tag used if nothing is specified in specialized functions
55 """
56 TileCalibLogger.__init__(self,"DefaultWriter")
57 self.__author = os.getlogin()
58 try:
59 if not db.isOpen():
60 raise Exception ("DB not open: ", db.databaseName())
61 else:
62 self.__db = db
63 self.__tilePrefixOfl1 = TileCalibTools.getTilePrefix(True,False)
64 #--- splitOnlineFolders in offline schema
65 self.__tilePrefixOfl = TileCalibTools.getTilePrefix(True,True)
66 self.__tilePrefixOnl = TileCalibTools.getTilePrefix(False)
67 #=== force the creation of template classes
68 except Exception as e:
69 self.log().critical( e )
70
71
72 #____________________________________________________________________
73 def writeCis(self, tag="", loGainDef=(1023./800.), hiGainDef=(64.*1023./800.)):
74
75 self.log().info( "*** Writing CIS with defaults loGain=%f, hiGain=%f and tag %s",
76 loGainDef,hiGainDef,tag )
77
78 #=== fill LIN (linear) folders first
79 loGainDefVec = cppyy.gbl.std.vector('float')()
80 loGainDefVec.push_back(loGainDef)
81 hiGainDefVec = cppyy.gbl.std.vector('float')()
82 hiGainDefVec.push_back(hiGainDef)
83 defVec = cppyy.gbl.std.vector('std::vector<float>')()
84 defVec.push_back(loGainDefVec)
85 defVec.push_back(hiGainDefVec)
86
87 #=== folders
88 # folders = [self.__tilePrefixOfl+"CALIB/CIS/FIT/",
89 # self.__tilePrefixOfl+"CALIB/CIS/OF1/",
90 # self.__tilePrefixOfl+"CALIB/CIS/OF2/",
91 # self.__tilePrefixOfl+"CALIB/CIS/FMA/",
92 # self.__tilePrefixOfl+"CALIB/CIS/FLT/"]
93 folders = [self.__tilePrefixOfl+"CALIB/CIS/LIN",
94 self.__tilePrefixOnl+"CALIB/CIS/LIN"]
95
96 for folder in folders:
97 multiVers=('OFL' in folder)
98 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
99
100 #=== initialize all channels
101 util = cppyy.gbl.TileCalibUtils()
102 for ros in range(util.max_ros()):
103 for drawer in range(util.getMaxDrawer(ros)):
104 flt = blobWriter.zeroBlob(ros,drawer)
105 #=== only write to global defaul drawer ROS=0/drawer=0
106 flt = blobWriter.getDrawer(0,0)
107 flt.init(defVec,1,1)
108 blobWriter.setComment(self.__author,"CIS defaults")
109 #=== register
110 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
111 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
112
113 #=== fill NLN (non-linear) folders with unit corretion
114 #=== Note: first insert all x values, then all y values
115 #=== LUT for all channels and gains must have the same length
116 lut = cppyy.gbl.std.vector('float')()
117 lut.push_back(0.) # x1
118 lut.push_back(1.) # y1
119 defVec.clear()
120 defVec.push_back(lut) # one default LUT for lo & hi gain
121
122 folders = [self.__tilePrefixOfl+"CALIB/CIS/NLN",
123 self.__tilePrefixOnl+"CALIB/CIS/NLN"]
124
125 for folder in folders:
126 multiVers=('OFL' in folder)
127 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
128
129 #=== initialize all channels
130 for ros in range(util.max_ros()):
131 for drawer in range(util.getMaxDrawer(ros)):
132 flt = blobWriter.zeroBlob(ros,drawer)
133 #=== only write to global defaul drawer ROS=0/drawer=0
134 flt = blobWriter.getDrawer(0,0)
135 flt.init(defVec,1,100)
136 blobWriter.setComment(self.__author,"non-linear CIS defaults")
137 #=== register
138 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
139 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
140
141
142 #____________________________________________________________________
143 def writeLas(self, tag=""):
144
145 self.log().info( "*** Writing Las default (1.) with tag %s", tag )
146
147 #=== write linear (LIN) folders online and offline
148 lasDef = cppyy.gbl.std.vector('float')()
149 lasDef.push_back(1.)
150 defVec = cppyy.gbl.std.vector('std::vector<float>')()
151 defVec.push_back(lasDef)
152
153 #=== write both to offline and online folders
154
155 folders = [self.__tilePrefixOfl+"CALIB/LAS/LIN",
156 self.__tilePrefixOnl+"CALIB/LAS/LIN"]
157
158 for folder in folders:
159 multiVers=('OFL' in folder)
160 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
161
162 #=== initialize all channels
163 util = cppyy.gbl.TileCalibUtils()
164 for ros in range(util.max_ros()):
165 for drawer in range(util.getMaxDrawer(ros)):
166 flt = blobWriter.zeroBlob(ros,drawer)
167 #=== only write to global defaul drawer ROS=0/drawer=0
168 flt = blobWriter.getDrawer(0,0)
169 flt.init(defVec,1,1)
170 blobWriter.setComment(self.__author,"LAS default")
171 #=== register
172 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
173 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
174
175 #=== fill NLN (non-linear) folders with unit corretion
176 lut = cppyy.gbl.std.vector('float')()
177 lut.push_back(0.) # x1
178 lut.push_back(1.) # y1
179 defVec.clear()
180 defVec.push_back(lut)
181
182 #=== write both to offline and online folders
183 folders = [self.__tilePrefixOfl+"CALIB/LAS/NLN",
184 self.__tilePrefixOnl+"CALIB/LAS/NLN"]
185
186 for folder in folders:
187 multiVers=('OFL' in folder)
188 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
189
190 #=== initialize all channels
191 util = cppyy.gbl.TileCalibUtils()
192 for ros in range(util.max_ros()):
193 for drawer in range(util.getMaxDrawer(ros)):
194 flt = blobWriter.zeroBlob(ros,drawer)
195 #=== only write to global defaul drawer ROS=0/drawer=0
196 flt = blobWriter.getDrawer(0,0)
197 flt.init(defVec,1,100)
198 blobWriter.setComment(self.__author,"non-linear LAS default")
199 #=== register
200 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
201 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
202
203
204 #____________________________________________________________________
205 def writeLasFiber(self, tag=""):
206
207 self.log().info( "*** Writing Las fiber and partition defaults (1.) with tag %s", tag )
208
209 fibFolder = self.__tilePrefixOfl+"CALIB/LAS/FIBER"
210 #=== write fiber folder
211 lasDef = cppyy.gbl.std.vector('float')()
212 lasDef.push_back(1.)
213 defVec = cppyy.gbl.std.vector('std::vector<float>')()
214 defVec.push_back(lasDef)
215 blobWriter = TileCalibTools.TileBlobWriter(self.__db,fibFolder,'Flt')
216 #=== initialize all channels
217 util = cppyy.gbl.TileCalibUtils()
218 for ros in range(util.max_ros()):
219 for drawer in range(util.getMaxDrawer(ros)):
220 blobWriter.zeroBlob(ros,drawer)
221 #=== fiber variation: only write to global defaul drawer ROS=0/drawer=0
222 fltDrawer = blobWriter.getDrawer(0,0)
223 fltDrawer.init(defVec,1,1)
224
225 #=== partition variation: write to the 1st drawer of each partition into an empty channel 43 (LASPARTCHAN)
226 adc = 0
227 idx = 0
228 val = 1.0
229 for ros in range(1,util.max_ros()):
230 fltDrawer = blobWriter.getDrawer(ros,0)
231 fltDrawer.init(defVec,48,1)
232 fltDrawer.setData(LASPARTCHAN,adc,idx,val)
233
234 blobWriter.setComment(self.__author,"LAS fiber and partition default")
235 folderTag = TileCalibUtils.getFullTag(fibFolder, tag)
236 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
237
238
239 #____________________________________________________________________
240 def writeCes(self, tag="", Simulation=True, MBTSflag="7TeV", dCellWeight=1.2, eCellWeight=1.5, since=(MINRUN,MINLBK), until=(MAXRUN, MAXLBK), mode='DEFAULT'):
241 """
242 Write default drawer/mod=0/0 only for LBA and LBC.
243 EBA & EBC setup is messy and so each drawer is stored individually.
244 These values with dCellWeight = 1.0 correspond to real M7 ones.
245 These values with dCellWeight = 1.2 correspond to real M8 ones.
246 Mode = 'DEFAULT' means standard settings, any other mode means put 1 everywhere
247 and ignore weight for D-sampling.
248 """
249
250 self.log().info( "*** Writing Ces with tag %s", tag )
251
252 #=== special values != 1
253 #=== some info available here: https://twiki.cern.ch/twiki/bin/view/Atlas/SpecialModules
254 special = {}
255 #=== D-cells in LB
256 for ros in range(1,3):
257 for mod in range(64):
258 special[(ros,mod, 0)] = dCellWeight
259 special[(ros,mod,13)] = dCellWeight
260 special[(ros,mod,14)] = dCellWeight
261 special[(ros,mod,24)] = dCellWeight
262 special[(ros,mod,25)] = dCellWeight
263 special[(ros,mod,41)] = dCellWeight
264 special[(ros,mod,44)] = dCellWeight
265 #=== D-cells in EB
266 for ros in range(3,5):
267 for mod in range(64):
268 special[(ros,mod, 2)] = dCellWeight
269 special[(ros,mod, 3)] = dCellWeight
270 special[(ros,mod, 4)] = dCellWeight
271 special[(ros,mod, 5)] = dCellWeight
272 #=== E-cells in EB
273 for ros in range(3,5):
274 for mod in range(64):
275 special[(ros,mod, 0)] = eCellWeight
276 special[(ros,mod, 1)] = eCellWeight
277 special[(ros,mod,12)] = eCellWeight
278 special[(ros,mod,13)] = eCellWeight
279 special[(ros,mod,18)] = 1.0
280 special[(ros,mod,19)] = 1.0
281 #=== module type 11 anomalies (PMT 1,2,3,4 missing)
282 #=== EBA15 & EBC18
283 #----- PMT 1-4 not connected
284 special[(3,14, 0)] = 1.0
285 special[(3,14, 1)] = 1.0
286 special[(3,14, 2)] = 1.0
287 special[(3,14, 3)] = 1.0
288 special[(4,17, 0)] = 1.0
289 special[(4,17, 1)] = 1.0
290 special[(4,17, 2)] = 1.0
291 special[(4,17, 3)] = 1.0
292 #----- D4 & D5 merged, readout through D5 PMTs 17 & 18
293 special[(3,14,16)] = 1.0
294 special[(3,14,17)] = 1.0
295 special[(4,17,16)] = 1.0
296 special[(4,17,17)] = 1.0
297 #----- E3, E4 are routed to PMTs 19 & 20
298 special[(3,14,18)] = eCellWeight
299 special[(3,14,19)] = eCellWeight
300 special[(4,17,18)] = eCellWeight
301 special[(4,17,19)] = eCellWeight
302
303 #=== Modules with connected to MBTS scintillator in RUN2
304 #=== Index starts with 0, so e.g. 0 for EBA indicates module EBA01 for example.
305 mbts_inner = [38,39,40,41,54,55,56,57] #E6 in channel 4 PMT05
306 mbts_outer = [ 7,23,42,53] #E5 in channel 12 PMT13
307
308 #=== Modules with PMT1 connected to MBTS scintillator
309 #=== Index starts with 0, so e.g. 0 for EBA indicates module EBA01 for example.
310 eba_mbts_inner = [ 3,12,23,30,35,43,52,60] #E6
311 eba_mbts_outer = [ 2,11,22,29,34,44,53,59] #E5
312 ebc_mbts_inner = [ 4,12,19,27,36,44,54,61] #E6
313 ebc_mbts_outer = [ 3,11,18,26,35,43,53,60] #E5
314
315 #=== Mean value of beta used for PMTs whose beta was not measured
316 betaMean = 7.07
317
318 #=== Nominal HV and beta (must specify as floats for division later)
319 nomHV_EBA_inner = [ 694., 692.3, 697., 698., 695., 697., 696., 695.3 ]
320 beta_EBA_inner = [ 7.099, 7., 7.188, 6.995, 6.917, 7.217, 6.863, 6.97 ]
321
322 nomHV_EBA_outer = [ 687., 695., 697.7, 692., 695., 696., 694., 696. ]
323 beta_EBA_outer = [ 6.903, 7.01, betaMean, betaMean, 6.918, betaMean, 7.072, betaMean ]
324
325 nomHV_EBC_inner = [ 696., 697., 696., 693., 694., 698., 695., 690. ]
326 beta_EBC_inner = [ betaMean, 7.26, 7.281, 6.98, 7.002, 6.845, 6.955, 7.167 ]
327
328 nomHV_EBC_outer = [ 697., 695., 695., 696., 696., 695., 696., 697. ]
329 beta_EBC_outer = [ 7.209, 7.084, 7.272, 7.093, 7.207, 7.02, 7.298, betaMean ]
330
331 RUN=0
332 NEW="new"
333 if Simulation:
334 #=== Old cesium constants
335 corrFactor = 0.85
336 mev2pcb = 1.050/1000.
337 ces_mbts_inner = 2.5751/mev2pcb * corrFactor
338 ces_mbts_outer = 1.8438/mev2pcb * corrFactor
339
340 #=== MIP values, inner counters from 900 GeV data
341 mbtsMipInnerC=[]
342 mbtsMipInnerA=[]
343
344 #=== For inner counters, just scale mean outer peak by relative N_pe
345 for i in range(8):
346 mbtsMipInnerC.append(0.155 * 8.2/5.9)
347 mbtsMipInnerA.append(0.155 * 8.2/5.9)
348
349 #=== MIP values, outer counters from 900 GeV data
350 mbtsMipOuterC = [ 0.16, 0.14, 0.155, 0.165, 0.14, 0.15, 0.185, 0.145 ]
351 mbtsMipOuterA = [ 0.15, 0.165, 0.135, 0.155, 0.13, 0.155, 0.165, 0.18 ]
352
353 #=== New 900 GeV cesium constants
354 newCesMbtsOuterC=[]
355 newCesMbtsOuterA=[]
356 newCesMbtsInnerC=[]
357 newCesMbtsInnerA=[]
358 for i in range(8):
359 newCesMbtsOuterC.append( mbtsMipOuterC[i]/(10. * 5.9/8.2) * ces_mbts_outer )
360 newCesMbtsOuterA.append( mbtsMipOuterA[i]/(10. * 5.9/8.2) * ces_mbts_outer )
361 newCesMbtsInnerC.append( mbtsMipInnerC[i]/10. * ces_mbts_inner )
362 newCesMbtsInnerA.append( mbtsMipInnerA[i]/10. * ces_mbts_inner )
363
364 #=== Further tune 900 GeV cesium constants
365 newCesMbtsOuterC[0] *= 1.15
366
367 if not MBTSflag=="13TeV" and not MBTSflag=="8TeV" and not MBTSflag=="7TeV" and not MBTSflag=="900GeV":
368 print ("MBTS flag",MBTSflag,"is not recognized, assuming 7TeV")
369 MBTSflag="7TeV"
370 else:
371 print ("setting MBTS weights for",MBTSflag)
372
373 if MBTSflag=="13TeV" :
374 RUN=2
375 print ("RUN2 configuration for MC")
376
377 # Cesium constants to have pC afer deposited energy is multiplied by EMS(0.0105) and CES
378 ces_mbts_inner = 157.5/1.05 # connected to PMT5 of special C10
379 ces_mbts_outer = 157.5/1.05 # connected instead of E1
380 chan_mbts_inner = 5-1 # connected to PMT5 of special C10
381 chan_mbts_outer = 13-1 # connected instead of E1
382 NEW="150.0 as"
383
384 #----- EBA inner
385 for i,mod in enumerate(mbts_inner):
386 special[(3,mod,chan_mbts_inner)] = ces_mbts_inner
387 print ("EBA",mod+1,"ch",chan_mbts_inner," inner MBTS = ",special[(3,mod,chan_mbts_inner)] )
388 #----- EBA outer
389 for i,mod in enumerate(mbts_outer):
390 special[(3,mod,chan_mbts_outer)] = ces_mbts_outer
391 print ("EBA",mod+1,"ch",chan_mbts_outer," outer MBTS = ",special[(3,mod,chan_mbts_outer)] )
392 #----- EBC inner
393 for i,mod in enumerate(mbts_inner):
394 special[(4,mod,chan_mbts_inner)] = ces_mbts_inner
395 print ("EBC",mod+1,"ch",chan_mbts_inner," inner MBTS = ",special[(4,mod,chan_mbts_inner)] )
396 #----- EBC outer
397 for i,mod in enumerate(mbts_outer):
398 special[(4,mod,chan_mbts_outer)] = ces_mbts_outer
399 print ("EBC",mod+1,"ch",chan_mbts_outer," outer MBTS = ",special[(4,mod,chan_mbts_outer)] )
400
401 else:
402 RUN=1
403 print ("RUN1 configuration for MC")
404
405 #=== Changes for 7 TeV ======================================================
406 if MBTSflag=="7TeV" or MBTSflag=="8TeV" :
407
408 #=== PMT HV was increased from nominal to 850V (must specify as float for later division)
409 newHV = 850.
410 for i in range(8):
411 newCesMbtsOuterC[i] *= pow( newHV/nomHV_EBC_outer[i], beta_EBC_outer[i] )
412 newCesMbtsOuterA[i] *= pow( newHV/nomHV_EBA_outer[i], beta_EBA_outer[i] )
413 newCesMbtsInnerC[i] *= pow( newHV/nomHV_EBC_inner[i], beta_EBC_inner[i] )
414 newCesMbtsInnerA[i] *= pow( newHV/nomHV_EBA_inner[i], beta_EBA_inner[i] )
415
416 #=== EBA03 and EBA12 have HV = 820V instead of 850V; so rescale back down
417 for i in [0, 1]:
418 newCesMbtsOuterA[i] *= pow( 820./newHV, beta_EBA_outer[i] )
419
420 #=== EBC05 is dead, so set calibration constant to 0 (disable by hand)
421 if MBTSflag=="7TeV" :
422 newCesMbtsInnerC[0] = 1.0e-20
423
424 #=========================================================================
425
426 #----- EBA inner
427 for i,mod in enumerate(eba_mbts_inner):
428 special[(3,mod,0)] = newCesMbtsInnerA[i]
429 print ("EBA",mod+1," inner MBTS = ",special[(3,mod,0)] )
430 #----- EBA outer
431 for i,mod in enumerate(eba_mbts_outer):
432 special[(3,mod,0)] = newCesMbtsOuterA[i]
433 print ("EBA",mod+1," outer MBTS = ",special[(3,mod,0)] )
434 #----- EBC inner
435 for i,mod in enumerate(ebc_mbts_inner):
436 special[(4,mod,0)] = newCesMbtsInnerC[i]
437 print ("EBC",mod+1," inner MBTS = ",special[(4,mod,0)] )
438 #----- EBC outer
439 for i,mod in enumerate(ebc_mbts_outer):
440 special[(4,mod,0)] = newCesMbtsOuterC[i]
441 print ("EBC",mod+1, " outer MBTS = ",special[(4,mod,0)] )
442
443 else:
444
445 if MBTSflag=="13TeV" :
446 RUN=2
447 print ("RUN2 configuration for DATA")
448
449 # Cesium constants to have fC in BS file for MBTS
450 ces_mbts_inner = (1.036 * 0.987)/1.05 # connected to PMT5 of special C10
451 ces_mbts_outer = 1.0/1.05 # connected instead of E1
452 chan_mbts_inner = 5-1 # connected to PMT5 of special C10
453 chan_mbts_outer = 13-1 # connected instead of E1
454
455 #----- EBA inner
456 for i,mod in enumerate(mbts_inner):
457 special[(3,mod,chan_mbts_inner)] = ces_mbts_inner
458 print ("EBA",mod+1,"ch",chan_mbts_inner," inner MBTS = ",special[(3,mod,chan_mbts_inner)] )
459 #----- EBA outer
460 for i,mod in enumerate(mbts_outer):
461 special[(3,mod,chan_mbts_outer)] = ces_mbts_outer
462 print ("EBA",mod+1,"ch",chan_mbts_outer," outer MBTS = ",special[(3,mod,chan_mbts_outer)] )
463 #----- EBC inner
464 for i,mod in enumerate(mbts_inner):
465 special[(4,mod,chan_mbts_inner)] = ces_mbts_inner
466 print ("EBC",mod+1,"ch",chan_mbts_inner," inner MBTS = ",special[(4,mod,chan_mbts_inner)] )
467 #----- EBC outer
468 for i,mod in enumerate(mbts_outer):
469 special[(4,mod,chan_mbts_outer)] = ces_mbts_outer
470 print ("EBC",mod+1,"ch",chan_mbts_outer," outer MBTS = ",special[(4,mod,chan_mbts_outer)] )
471
472 else:
473 RUN=1
474 print ("RUN1 configuration for DATA")
475
476 # Cesium constants to have fC in BS file for MBTS
477 ces_mbts_inner = 1.0/1.05
478 ces_mbts_outer = 1.0/1.05
479
480 #----- EBA inner
481 for mod in eba_mbts_inner:
482 special[(3,mod,0)] = ces_mbts_inner
483 print ("EBA",mod+1," inner MBTS = ",special[(3,mod,0)] )
484 #----- EBA outer
485 for mod in eba_mbts_outer:
486 special[(3,mod,0)] = ces_mbts_outer
487 print ("EBA",mod+1," outer MBTS = ",special[(3,mod,0)] )
488 #----- EBC inner
489 for mod in ebc_mbts_inner:
490 special[(4,mod,0)] = ces_mbts_inner
491 print ("EBC",mod+1," inner MBTS = ",special[(4,mod,0)] )
492 #----- EBC outer
493 for mod in ebc_mbts_outer:
494 special[(4,mod,0)] = ces_mbts_outer
495 print ("EBC",mod+1, " outer MBTS = ",special[(4,mod,0)] )
496
497 #=== store 4 values per channel
498 default = cppyy.gbl.std.vector('float')()
499 if Simulation:
500 default.push_back( 1.) # cesium constant
501 default.push_back( 1.) # laser slope
502 default.push_back(700.) # reference HV
503 default.push_back( 20.) # reference temperature (same for all channels)
504 else:
505 default.push_back( 1.) # cesium constant
506 default.push_back( -1.) # laser slope
507 default.push_back( 0.) # reference HV
508 default.push_back( 20.) # reference temperature (same for all channels)
509 defVec = cppyy.gbl.std.vector('std::vector<float>')()
510 defVec.push_back(default)
511
512 #=== write both to offline and online folders
513 folders = [self.__tilePrefixOfl+"CALIB/CES",
514 self.__tilePrefixOnl+"CALIB/CES"]
515
516 for folder in folders:
517 multiVers=('OFL' in folder)
518 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
519
520 #=== initialize all channels
521 util = cppyy.gbl.TileCalibUtils()
522 for ros in range(util.max_ros()):
523 for drawer in range(util.getMaxDrawer(ros)):
524 flt = blobWriter.zeroBlob(ros,drawer)
525
526 #=== global detector default
527 det = blobWriter.getDrawer(0,0)
528 det.init(defVec,48,1)
529
530 #=== default settings (including all special cases)
531 if mode=='DEFAULT':
532 self.log().info( "*** Writing Ces defaults with dCellWeight = %.1f eCellWeight = %.1f", dCellWeight,eCellWeight )
533 #=== defaults for LBA & LBC
534 lba = blobWriter.getDrawer(0,4)
535 lba.init(defVec,48,1)
536 lbc = blobWriter.getDrawer(0,8)
537 lbc.init(defVec,48,1)
538 for chan in range(48):
539 key = (1,0,chan)
540 ces = special.get(key,1.)
541 lba.setData(chan,0,0,ces)
542 lbc.setData(chan,0,0,ces)
543
544 #=== defaults for EBA & EBC
545 eba = blobWriter.getDrawer(0,12)
546 eba.init(defVec,48,1)
547 ebc = blobWriter.getDrawer(0,16)
548 ebc.init(defVec,48,1)
549 for chan in range(48):
550 key = (3,0,chan)
551 ces = special.get(key,1.)
552 eba.setData(chan,0,0,ces)
553 ebc.setData(chan,0,0,ces)
554
555 #=== defaults for EBA & EBC
556 #=== store each drawer individually
557 for ros in range(3,5):
558 for mod in range(64):
559 flt = blobWriter.getDrawer(ros,mod)
560 flt.init(defVec,48,1)
561 for chan in range(48):
562 key = (ros,mod,chan)
563 ces = special.get(key,1.)
564 flt.setData(chan,0,0,ces)
565
566 #=== set comment
567 blobWriter.setComment(self.__author,"default cesium constants for Run %d and %s MBTS weights for %s" % (RUN,NEW,MBTSflag))
568
569 #=== special case: write cesium = 1 everywhere
570 else: # (mode != 'DEFAULT')
571 self.log().info( "*** Writing Ces = 1 everywhere" )
572 #=== set comment
573 blobWriter.setComment(self.__author,"cesium constants = 1 everywhere")
574
575 #=== register
576 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
577 blobWriter.register(since,until,folderTag)
578
579
580 #____________________________________________________________________
581 def writeOldCes(self, tag="", dCellWeight=1.2, eCellWeight=1.5, since=(MINRUN,MINLBK), until=(MAXRUN, MAXLBK)):
582 """
583 Write default drawer/mod=0/0 only for LBA and LBC.
584 EBA & EBC setup is messy and so each drawer is stored individually.
585 MBTS in EBs connected in channel 47. No module type 11 anomaly.
586 These values with dCellWeight = 1.2 correspond to simulation with CSC and FDR global tags.
587 """
588
589 self.log().info( "*** Writing Ces with tag %s", tag )
590
591 #=== special values != 1
592 special = {}
593 #=== D-cells in LB
594 for ros in range(1,3):
595 for mod in range(64):
596 special[(ros,mod, 0)] = dCellWeight
597 special[(ros,mod,13)] = dCellWeight
598 special[(ros,mod,14)] = dCellWeight
599 special[(ros,mod,24)] = dCellWeight
600 special[(ros,mod,25)] = dCellWeight
601 special[(ros,mod,41)] = dCellWeight
602 special[(ros,mod,44)] = dCellWeight
603 #=== D-cells in EB
604 for ros in range(3,5):
605 for mod in range(64):
606 special[(ros,mod, 2)] = dCellWeight
607 special[(ros,mod, 3)] = dCellWeight
608 special[(ros,mod, 4)] = dCellWeight
609 special[(ros,mod, 5)] = dCellWeight
610 #=== E-cells in EB
611 for ros in range(3,5):
612 for mod in range(64):
613 special[(ros,mod, 0)] = eCellWeight
614 special[(ros,mod, 1)] = eCellWeight
615 special[(ros,mod,12)] = eCellWeight
616 special[(ros,mod,13)] = eCellWeight
617 #=== EB modules with channel 47 connected to MBTS scintillator
618 #mev2pcb = 1.050/1000.
619 #ces_mbts_inner = 2.5751/mev2pcb
620 #ces_mbts_outer = 1.8438/mev2pcb
621 ces_mbts_inner = 1.0/1.05
622 ces_mbts_outer = 1.0/1.05
623 eb_mbts_inner = [ 0, 1, 2, 3,
624 8, 9,10,11,
625 16,17,18,19,
626 24,25,26,27,
627 32,33,34,35,
628 40,41,42,43,
629 48,49,50,51,
630 56,57,58,59
631 ] #E6
632 eb_mbts_outer = [ 4, 5, 6, 7,
633 12,13,14,15,
634 20,21,22,23,
635 28,29,30,31,
636 36,37,38,39,
637 44,45,46,47,
638 52,53,54,55,
639 60,61,62,63] #E5
640 #----- EBA and EBC inner
641 for mod in eb_mbts_inner:
642 special[(3,mod,47)] = ces_mbts_inner
643 special[(4,mod,47)] = ces_mbts_inner
644 #----- EBA and EBC outer
645 for mod in eb_mbts_outer:
646 special[(3,mod,47)] = ces_mbts_outer
647 special[(4,mod,47)] = ces_mbts_outer
648
649 #=== store 4 values per channel
650 default = cppyy.gbl.std.vector('float')()
651 default.push_back( 1.) # cesium constant
652 default.push_back( 1.) # laser slope
653 default.push_back(700.) # reference HV
654 default.push_back( 20.) # reference temperature (same for all channels)
655 defVec = cppyy.gbl.std.vector('std::vector<float>')()
656 defVec.push_back(default)
657
658 #=== write both to offline and online folders
659 folderOfl = self.__tilePrefixOfl+"CALIB/CES"
660 folderOnl = self.__tilePrefixOnl+"CALIB/CES"
661 blobWriterOfl = TileCalibTools.TileBlobWriter(self.__db,folderOfl,'Flt' )
662 blobWriterOnl = TileCalibTools.TileBlobWriter(self.__db,folderOnl,'Flt',False)
663
664 #=== initialize all channels
665 util = cppyy.gbl.TileCalibUtils()
666 for ros in range(util.max_ros()):
667 for drawer in range(util.getMaxDrawer(ros)):
668 fltOfl = blobWriterOfl.zeroBlob(ros,drawer)
669 fltOnl = blobWriterOnl.zeroBlob(ros,drawer)
670
671 #=== global detector default
672 detOfl = blobWriterOfl.getDrawer(0,0)
673 detOfl.init(defVec,48,1)
674 detOnl = blobWriterOnl.getDrawer(0,0)
675 detOnl.init(defVec,48,1)
676
677 #=== default settings (including all special cases)
678 self.log().info( "*** Writing Ces defaults with dCellWeight = %.1f eCellWeight = %.1f", dCellWeight,eCellWeight )
679 #=== defaults for LBA & LBC
680 lbaOfl = blobWriterOfl.getDrawer(0,4)
681 lbaOfl.init(defVec,48,1)
682 lbaOnl = blobWriterOnl.getDrawer(0,4)
683 lbaOnl.init(defVec,48,1)
684 lbcOfl = blobWriterOfl.getDrawer(0,8)
685 lbcOfl.init(defVec,48,1)
686 lbcOnl = blobWriterOnl.getDrawer(0,8)
687 lbcOnl.init(defVec,48,1)
688 for chan in range(48):
689 key = (1,0,chan)
690 ces = special.get(key,1.)
691 lbaOfl.setData(chan,0,0,ces)
692 lbaOnl.setData(chan,0,0,ces)
693 lbcOfl.setData(chan,0,0,ces)
694 lbcOnl.setData(chan,0,0,ces)
695
696 #=== defaults for EBA & EBC
697 #=== store each drawer individually
698 for ros in range(3,5):
699 for mod in range(64):
700 fltOfl = blobWriterOfl.getDrawer(ros,mod)
701 fltOfl.init(defVec,48,1)
702 fltOnl = blobWriterOnl.getDrawer(ros,mod)
703 fltOnl.init(defVec,48,1)
704 for chan in range(48):
705 key = (ros,mod,chan)
706 ces = special.get(key,1.)
707 fltOfl.setData(chan,0,0,ces)
708 fltOnl.setData(chan,0,0,ces)
709
710 #=== set comment
711 blobWriterOfl.setComment(self.__author,"default old cesium constants (CSC,FDR) with dCellWeight=%.1f" % dCellWeight)
712 blobWriterOnl.setComment(self.__author,"default old cesium constants (CSC,FDR) with dCellWeight=%.1f" % dCellWeight)
713
714 #=== register
715 folderTag = TileCalibUtils.getFullTag(folderOfl, tag)
716 blobWriterOfl.register(since,until,folderTag)
717 blobWriterOnl.register(since,until, "")
718
719
720 #____________________________________________________________________
721 def writeEmscale(self, tag="", since=(MINRUN,MINLBK), until=(MAXRUN, MAXLBK)):
722
723 #=== EM scale constants as described in ATLAS Note "Calibration of
724 #=== ATLAS Tile Calorimeter at Electromagnetic Scale"
725 #--- A-sampling base pC/MeV factor
726 emscale=(1.05/1000.)
727 #--- additional particle/Cs factors for corresponding channels
728 #--- we insert emscale/(p/Cs) as we must increase the MeV denominator
729 #--- long barrel modules
730 #--- additional factors came from presentation by A.Solodkov
731 #--- at TileCal Calibration meeting on 16-Nov-2009
732 #--- correction because of slightly wrong normalization Integral2008/Amplitude2001
733 flbA = 1.000
734 flbB = 1.025 * 1.011
735 flbB9= 1.014 * 1.015 # tilerows B4-6
736 flbD = 1.088 * 0.978
737 clbA = [1, 4, 5, 8, 9, 10, 15, 18, 19, 20, 23, 26, 29, 32, 35, 36, 37, 38, 45, 46]
738 clbB = [2, 3, 6, 7, 11, 12, 16, 17, 21, 22, 27, 28, 33, 34, 39, 40]
739 clbB9= [42, 47]
740 clbD = [0, 13, 14, 24, 25, 41, 44]
741
742 #--- extended barrel modules
743 febA = 1.000
744 febB = 1.009 * 1.012
745 febD = 1.055 * 0.992
746 cebA = [6, 7, 10, 11, 20, 21, 31, 32, 40, 41]
747 cebB = [8, 9, 14, 15, 22, 23, 30, 35, 36, 39]
748 cebD = [16, 17, 37, 38]
749
750 #--- ITC cells
751 fC10 = 1.036 * 0.987 # tilerows BC7-9
752 fD4 = flbD # composed of the same tilerows as barrel D-sampling
753 cC10 = [4, 5]
754 cD4 = [2, 3]
755
756 self.log().info( "*** Writing Emscale with particle/Cesium factors with tag %s" , tag )
757
758 #=== write linear (LIN) folder
759 emsDef = cppyy.gbl.std.vector('float')()
760 emsDef.push_back(emscale)
761 defVec = cppyy.gbl.std.vector('std::vector<float>')()
762 defVec.push_back(emsDef)
763
764 folders = [ self.__tilePrefixOfl+"CALIB/EMS",
765 self.__tilePrefixOnl+"CALIB/EMS" ]
766
767 for folder in folders:
768 multiVers=('OFL' in folder)
769 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
770
771 #=== initialize all channels
772 util = cppyy.gbl.TileCalibUtils()
773 for ros in range(util.max_ros()):
774 for drawer in range(util.getMaxDrawer(ros)):
775 flt = blobWriter.zeroBlob(ros,drawer)
776
777 #=== write EM scale as global default and explicitly too
778 flt = blobWriter.getDrawer(0,0)
779 flt.init(defVec,1,1)
780
781 #=== LB values
782 for ros in range(1,3):
783 for mod in range(64):
784 flt = blobWriter.getDrawer(ros,mod)
785 flt.init(defVec,48,1)
786 for chan in clbA:
787 flt.setData(chan,0,0,emscale/flbA)
788 for chan in clbB:
789 flt.setData(chan,0,0,emscale/flbB)
790 for chan in clbB9:
791 flt.setData(chan,0,0,emscale/flbB9)
792 for chan in clbD:
793 flt.setData(chan,0,0,emscale/flbD)
794
795 #=== EB and ITC values
796 for ros in range(3,5):
797 for mod in range(64):
798 flt = blobWriter.getDrawer(ros,mod)
799 flt.init(defVec,48,1)
800 for chan in cebA:
801 flt.setData(chan,0,0,emscale/febA)
802 for chan in cebB:
803 flt.setData(chan,0,0,emscale/febB)
804 for chan in cebD:
805 flt.setData(chan,0,0,emscale/febD)
806 for chan in cC10:
807 flt.setData(chan,0,0,emscale/fC10)
808 for chan in cD4:
809 flt.setData(chan,0,0,emscale/fD4)
810
811 blobWriter.setComment(self.__author,"EMS with particle/Cesium factors (pC/MeV)")
812 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
813 blobWriter.register(since,until,folderTag)
814
815
816 #____________________________________________________________________
817 def writeEmscaleMC(self, tag="", emscale=(1.05/1000.), since=(MINRUN,MINLBK), until=(MAXRUN, MAXLBK)):
818
819 self.log().info( "*** Writing Emscale default (%.2f) with tag %s", (emscale * 1000.),tag )
820
821 #=== write linear (LIN) folder
822 emsDef = cppyy.gbl.std.vector('float')()
823 emsDef.push_back(emscale)
824 defVec = cppyy.gbl.std.vector('std::vector<float>')()
825 defVec.push_back(emsDef)
826
827 folders = [ self.__tilePrefixOfl+"CALIB/EMS",
828 self.__tilePrefixOnl+"CALIB/EMS" ]
829
830 for folder in folders:
831 multiVers=('OFL' in folder)
832 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
833 #=== initialize all channels
834 util = cppyy.gbl.TileCalibUtils()
835 for ros in range(util.max_ros()):
836 for drawer in range(util.getMaxDrawer(ros)):
837 flt = blobWriter.zeroBlob(ros,drawer)
838 #=== only write to global defaul drawer ROS=0/drawer=0
839 flt = blobWriter.getDrawer(0,0)
840 flt.init(defVec,1,1)
841 blobWriter.setComment(self.__author,"EMS default: %.2f/1000 pC/MeV" % (emscale * 1000.))
842 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
843 blobWriter.register(since,until,folderTag)
844
845
846 #________________________________________________________________________
847 def writeIntegrator(self, tag=""):
848
849 #=== construct folder path
850 folder = self.__tilePrefixOfl+"INTEGRATOR"
851
852 #=== get full folder tag
853 folderTag = TileCalibUtils.getFullTag(folder, tag)
854
855 #=== create default values for each of the six gains 1 to 6
856 # for each gain there is:
857 # gain, error of the gain, chi2 of the fit, pedestal
858 # DAC for pedestal, sigma of pedestal distribution
859 # RMS of pedestal distribution, sigma of the RMS
860
861 dv = []
862 dv.append(( 2.814, 0.023, -1, -1, 80, -1, -1, -1))
863 dv.append(( 26.010, 0.230, -1, -1, 80, -1, -1, -1))
864 dv.append(( 28.810, 0.240, -1, -1, 80, -1, -1, -1))
865 dv.append(( 54.810, 0.480, -1, -1, 70, -1, -1, -1))
866 dv.append(( 75.790, 0.677, -1, -1, 70, -1, -1, -1))
867 dv.append((101.800, 0.900, -1, -1, 70, -1, -1, -1))
868
869 #=== number of integrator gains and value per gain
870 ngain = 6
871
872 defVec = cppyy.gbl.std.vector('std::vector<float>')()
873
874 for i in range(ngain):
875 defaultGain = cppyy.gbl.std.vector('float')()
876 for v in dv[i]:
877 defaultGain.push_back(v)
878 defVec.push_back(defaultGain)
879
880 #=====================================================
881 #=== fill
882 #=====================================================
883 writer = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
884 writer.setComment(self.__author,"Integrator gain defaults")
885 #=== initialize all channels and write global default
886 util = cppyy.gbl.TileCalibUtils()
887 for ros in range(util.max_ros()):
888 for drawer in range(util.getMaxDrawer(ros)):
889 writer.zeroBlob(ros,drawer)
890 calibDrawer = writer.getDrawer(0,0)
891 calibDrawer.init(defVec,1,1)
892
893 #=== register in DB
894 writer.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
895
896
897 #____________________________________________________________________
898 def writeTcfib(self, tag=""):
899
900
901 # NGO need to implement cell fiber length for special type 11 (?) modules!
902 self.log().info( "*** Writing Tcfib defaults using tag %s", tag )
903
904 parser = TileCalibTools.TileASCIIParser(pathDef+"TileTcfib.dat","Tfib")
905 folder = self.__tilePrefixOfl+"TIME/CELLFIBERLENGTH"
906 default = cppyy.gbl.std.vector('float')()
907 default.push_back(0.)
908 defVec = cppyy.gbl.std.vector('std::vector<float>')()
909 defVec.push_back(default)
910 try:
911 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
912 #=== initialize all channels
913 util = cppyy.gbl.TileCalibUtils()
914 for ros in range(util.max_ros()):
915 for drawer in range(util.getMaxDrawer(ros)):
916 blobWriter.zeroBlob(ros,drawer)
917
918 #=== default for detector
919 det = blobWriter.getDrawer(0, 0)
920 det.init(defVec,48,0)
921 #=== default for LBA
922 lba = blobWriter.getDrawer(0, 4)
923 lba.init(defVec,48,0)
924 #=== default for LBC
925 lbc = blobWriter.getDrawer(0, 8)
926 lbc.init(defVec,48,0)
927 #=== default for EBA
928 eba = blobWriter.getDrawer(0,12)
929 eba.init(defVec,48,0)
930 #=== default for EBC
931 ebc = blobWriter.getDrawer(0,16)
932 ebc.init(defVec,48,0)
933 for chan in range(48):
934 valLba = float(parser.getData(1,0,chan)[0])
935 valLbc = float(parser.getData(2,0,chan)[0])
936 valEba = float(parser.getData(3,0,chan)[0])
937 valEbc = float(parser.getData(4,0,chan)[0])
938 lba.setData(chan,0,0,valLba)
939 lbc.setData(chan,0,0,valLbc)
940 eba.setData(chan,0,0,valEba)
941 ebc.setData(chan,0,0,valEbc)
942 blobWriter.setComment(self.__author,"channel (laser) clear fiber length")
943 folderTag = TileCalibUtils.getFullTag(folder, tag)
944 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
945 except Exception as e:
946 self.log().critical( e )
947
948
949 #____________________________________________________________________
950 def writeTclas(self, tag=""):
951
952 self.log().info( "*** Writing Tclas defaults using tag %s", tag )
953
954 folder = self.__tilePrefixOfl+"TIME/CHANNELOFFSET/LAS"
955 default = cppyy.gbl.std.vector('float')()
956 default.push_back(0.)
957 defVec = cppyy.gbl.std.vector('std::vector<float>')()
958 defVec.push_back(default)
959 try:
960 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
961 #=== initialize all channels
962 util = cppyy.gbl.TileCalibUtils()
963 for ros in range(util.max_ros()):
964 for drawer in range(util.getMaxDrawer(ros)):
965 flt = blobWriter.zeroBlob(ros,drawer)
966 flt = blobWriter.getDrawer(0, 0)
967 flt.init(defVec,1,0)
968 blobWriter.setComment(self.__author,"no channel timing offset by default")
969 folderTag = TileCalibUtils.getFullTag(folder, tag)
970 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
971 except Exception as e:
972 self.log().critical( e )
973
974
975 #____________________________________________________________________
976 def writeTdlas(self, tag=""):
977
978 self.log().info( "*** Writing Tdlas defaults using tag %s", tag )
979
980 folder = self.__tilePrefixOfl+"TIME/DRAWEROFFSET/LAS"
981 default = cppyy.gbl.std.vector('float')()
982 default.push_back(0.)
983 defVec = cppyy.gbl.std.vector('std::vector<float>')()
984 defVec.push_back(default)
985 try:
986 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
987 #=== initialize only one channel per drawer
988 util = cppyy.gbl.TileCalibUtils()
989 for ros in range(util.max_ros()):
990 for drawer in range(util.getMaxDrawer(ros)):
991 flt = blobWriter.zeroBlob(ros,drawer)
992 flt = blobWriter.getDrawer(0, 0)
993 flt.init(defVec,1,0)
994 blobWriter.setComment(self.__author,"no drawer timing offset by default")
995 folderTag = TileCalibUtils.getFullTag(folder, tag)
996 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
997 except Exception as e:
998 self.log().critical( e )
999
1000
1001 #____________________________________________________________________
1002 def writeTof(self, tag=""):
1003
1004 self.log().info( "*** Writing Tof defaults using tag %s", tag )
1005
1006 parser = TileCalibTools.TileASCIIParser(pathDef+"Tile.tctof","Tctof")
1007 folder = self.__tilePrefixOfl+"TIME/TIMEOFFLIGHT"
1008 default = cppyy.gbl.std.vector('float')()
1009 default.push_back(0.)
1010 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1011 defVec.push_back(default)
1012 try:
1013 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
1014 #=== initialize all channels and write global default
1015 util = cppyy.gbl.TileCalibUtils()
1016 for ros in range(util.max_ros()):
1017 for drawer in range(util.getMaxDrawer(ros)):
1018 blobWriter.zeroBlob(ros,drawer)
1019 calibDrawer = blobWriter.getDrawer(0,0)
1020 calibDrawer.init(defVec,1,1)
1021
1022 #=== loop over the partitions
1023 ros = 0
1024 for mod in (4, 8, 12, 16):
1025 #=== need to invalidate previous blob in DB when reading from ASCII file
1026 blobWriter.zeroBlob(ros,mod)
1027 for chn in range(48):
1028 value = parser.getData(ros,mod,chn)
1029 if not len(value):
1030 self.log().warning("%i/%2i/%2i/x: No value found in file", ros,mod,chn)
1031 continue
1032 #=== init drawer with defaults for first entry
1033 calibDrawer = blobWriter.getDrawer(ros,mod)
1034 if not calibDrawer.getNObjs():
1035 self.log().info("Initializing drawer %i/%2i\t%i", ros,mod,calibDrawer.getNObjs())
1036 calibDrawer.init(defVec,48,1)
1037
1038 #=== set the data
1039 adc = 0
1040 line = "%i/%2i/%2i/%i: " % (ros,mod,chn,adc)
1041 val = float(value[0])
1042 calibDrawer.setData(chn,adc,0,val)
1043 line += "%f " % (val,)
1044 self.log().debug(line)
1045
1046 blobWriter.setComment("jose maneira","time-of-flight default values")
1047 folderTag = TileCalibUtils.getFullTag(folder, tag)
1048 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1049 except Exception as e:
1050 self.log().critical( e )
1051
1052
1053 #____________________________________________________________________
1054 def writeNoiseFit(self, tag="", loGainDef=0.8, hiGainDef=1.6):
1055
1056 self.log().info( "*** Writing Fit Method Noise with defaults (ADC counts) loGain=%f, hiGain=%f and tag %s" ,
1057 loGainDef,hiGainDef,tag )
1058
1059 #=== fill folders
1060 loGainDefVec = cppyy.gbl.std.vector('float')()
1061 loGainDefVec.push_back(loGainDef)
1062 hiGainDefVec = cppyy.gbl.std.vector('float')()
1063 hiGainDefVec.push_back(hiGainDef)
1064 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1065 defVec.push_back(loGainDefVec)
1066 defVec.push_back(hiGainDefVec)
1067
1068 #=== folders
1069 folders = [self.__tilePrefixOfl+"NOISE/FIT",
1070 self.__tilePrefixOfl+"NOISE/OF1",
1071 self.__tilePrefixOfl+"NOISE/OF2"]
1072
1073 for folder in folders:
1074 try:
1075 multiVers=('OFL' in folder)
1076 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
1077 #=== initialize all channels
1078 util = cppyy.gbl.TileCalibUtils()
1079 for ros in range(util.max_ros()):
1080 for drawer in range(util.getMaxDrawer(ros)):
1081 flt = blobWriter.zeroBlob(ros,drawer)
1082 #=== only write to global defaul drawer ROS=0/drawer=0
1083 flt = blobWriter.getDrawer(0,0)
1084 flt.init(defVec,1,1)
1085 blobWriter.setComment(self.__author,"Fit Method Noise defaults (ADC)")
1086 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1087 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1088 except Exception as e:
1089 self.log().critical( e )
1090
1091
1092 #____________________________________________________________________
1093 def writeNoiseSample(self, tag="", loGainDef=0.8, hiGainDef=1.6):
1094
1095 self.log().info( "*** Writing sample noise (lo=%f, hi=%f) defaults using tag %s",
1096 loGainDef,hiGainDef,tag )
1097
1098 #=== common noise defaults
1099 defaultLo = cppyy.gbl.std.vector('float')()
1100 defaultLo.push_back( 40.) # pedestal value
1101 defaultLo.push_back(loGainDef) # pedestal rms (high frequency noise)
1102 defaultLo.push_back( 0.) # (low frequency noise)
1103 defaultLo.push_back(loGainDef) # sigma 1 of HFN
1104 defaultLo.push_back( 0.) # sigma 2 of HFN
1105 defaultLo.push_back( 0.) # HFN2/HFN1 ratio
1106 defaultHi = cppyy.gbl.std.vector('float')()
1107 defaultHi.push_back( 40.) # pedestal value
1108 defaultHi.push_back(hiGainDef) # pedestal rms (high frequency noise)
1109 defaultHi.push_back( 0.) # (low frequency noise)
1110 defaultHi.push_back(hiGainDef) # sigma 1 of HFN
1111 defaultHi.push_back( 0.) # sigma 2 of HFN
1112 defaultHi.push_back( 0.) # HFN2/HFN1 ratio
1113 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1114 defVec.push_back(defaultLo)
1115 defVec.push_back(defaultHi)
1116
1117 folders = [self.__tilePrefixOfl+"NOISE/SAMPLE",
1118 self.__tilePrefixOnl+"NOISE/SAMPLE"]
1119
1120 for folder in folders:
1121 try:
1122 multiVers=('OFL' in folder)
1123 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
1124 #=== initialize all channels
1125 util = cppyy.gbl.TileCalibUtils()
1126 for ros in range(util.max_ros()):
1127 for drawer in range(util.getMaxDrawer(ros)):
1128 flt = blobWriter.zeroBlob(ros,drawer)
1129 flt = blobWriter.getDrawer(0, 0)
1130 flt.init(defVec,1,0)
1131 blobWriter.setComment(self.__author,"default noise")
1132 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1133 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1134 except Exception as e:
1135 self.log().critical( e )
1136
1137
1138 #____________________________________________________________________
1139 def writeRODmap(self, tag=""):
1140
1141 self.log().info( "*** Writing dummy RODmap using tag %s",tag)
1142
1143 default = cppyy.gbl.std.vector('int')()
1144 default.push_back(0x0) # offline drawer ID
1145 default.push_back(0x500000) # ROB ID for given drawer
1146 default.push_back(0x0) # bytestream frag ID
1147 default.push_back(0) # drawer type (0=legacy, 1=upgrade)
1148 defVec = cppyy.gbl.std.vector('std::vector<int>')()
1149 defVec.push_back(default)
1150 defVec.push_back(default)
1151
1152 folders = [self.__tilePrefixOfl+"STATUS/ROD",
1153 self.__tilePrefixOnl+"STATUS/ROD"]
1154
1155 for folder in folders:
1156 try:
1157 multiVers=('OFL' in folder)
1158 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Int',multiVers)
1159 #=== initialize all channels
1160 util = cppyy.gbl.TileCalibUtils()
1161 for ros in range(util.max_ros()):
1162 for drawer in range(util.getMaxDrawer(ros)):
1163 flt = blobWriter.zeroBlob(ros,drawer)
1164 flt = blobWriter.getDrawer(0, 0)
1165 flt.init(defVec,1,0)
1166 blobWriter.setComment(self.__author,"dummy ROD map")
1167 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1168 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1169 except Exception as e:
1170 self.log().critical( e )
1171
1172
1173 #____________________________________________________________________
1174 def writeNoiseOnl(self, tag="", loGainDef=0.8, hiGainDef=1.6):
1175
1176 self.log().info( "*** Writing 1-g noise(ADC counts)+pileup(MeV) defaults loGain=%f, hiGain=%f and tag %s",
1177 loGainDef,hiGainDef,tag )
1178
1179 #=== common noise defaults
1180 defaultLo = cppyy.gbl.std.vector('float')()
1181 defaultLo.push_back(loGainDef) # el. noise
1182 defaultLo.push_back(0.) # pileup noise
1183 defaultHi = cppyy.gbl.std.vector('float')()
1184 defaultHi.push_back(hiGainDef) # el. noise
1185 defaultHi.push_back(0.) # pileup noise
1186
1187 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1188 defVec.push_back(defaultLo)
1189 defVec.push_back(defaultHi)
1190
1191 folders = [self.__tilePrefixOfl+"NOISE/OFNI",
1192 self.__tilePrefixOnl+"NOISE/OFNI"]
1193
1194 for folder in folders:
1195 try:
1196 multiVers=('OFL' in folder)
1197 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
1198 #=== initialize all channels
1199 util = cppyy.gbl.TileCalibUtils()
1200 for ros in range(util.max_ros()):
1201 for drawer in range(util.getMaxDrawer(ros)):
1202 flt = blobWriter.zeroBlob(ros,drawer)
1203 #
1204 flt = blobWriter.getDrawer(0, 0)
1205 flt.init(defVec,48,1)
1206 #
1207 blobWriter.setComment(self.__author,"default noise for DSP reco")
1208 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1209 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1210 except Exception as e:
1211 self.log().critical( e )
1212
1213
1214 #____________________________________________________________________
1215 def writeNoiseSampleMC(self, tag="", loGainDef=0.8, hiGainDef=1.6):
1216 """
1217 To be compatible with previous defaults for MC, the low and high
1218 gain pedestals are set to ped+(channel+1)/48. with
1219 ped = 30 and 50 ADC counts respecively
1220 """
1221
1222 self.log().info( "*** Writing sample noise MC defaults (lo=%f, hi=%f) using tag %s",
1223 loGainDef,hiGainDef,tag )
1224
1225 folders = [self.__tilePrefixOfl+"NOISE/SAMPLE",
1226 self.__tilePrefixOnl+"NOISE/SAMPLE"]
1227
1228 for folder in folders:
1229 try:
1230 multiVers=('OFL' in folder)
1231 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',multiVers)
1232 #=== initialize all channels
1233 util = cppyy.gbl.TileCalibUtils()
1234 for ros in range(util.max_ros()):
1235 for drawer in range(util.getMaxDrawer(ros)):
1236 flt = blobWriter.zeroBlob(ros,drawer)
1237 flt = blobWriter.getDrawer(0, 0)
1238
1239 #=== initialize all channels in the drawer
1240
1241 defaultLo = cppyy.gbl.std.vector('float')()
1242 defaultLo.push_back(0.) # pedestal value
1243 defaultLo.push_back(0.) # pedestal rms (high frequency noise)
1244 defaultLo.push_back(0.) # (low frequency noise)
1245 defaultLo.push_back(0.) # sigma1 of high frequency noise
1246 defaultLo.push_back(0.) # sigma2 of high frequency noise
1247 defaultLo.push_back(0.) # HFN2/HFN1 normalization
1248
1249 defaultHi = cppyy.gbl.std.vector('float')()
1250 defaultHi.push_back(0.) # pedestal value
1251 defaultHi.push_back(0.) # pedestal rms (high frequency noise)
1252 defaultHi.push_back(0.) # (low frequency noise)
1253 defaultHi.push_back(0.) # sigma1 of high frequency noise
1254 defaultHi.push_back(0.) # sigma2 of high frequency noise)
1255 defaultHi.push_back(0.) # HFN2/HFN1 normalization
1256
1257 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1258 defVec.push_back(defaultLo)
1259 defVec.push_back(defaultHi)
1260
1261 flt.init(defVec,48,0)
1262
1263 #=== set common noise defaults per channel
1264 for chan in range(48):
1265
1266 loPedDef = 30.+(chan+1)/48.
1267 hiPedDef = 50.+(chan+1)/48.
1268
1269 #=== low gain defaults
1270 flt.setData(chan, 0, 0, loPedDef)
1271 flt.setData(chan, 0, 1, loGainDef)
1272 flt.setData(chan, 0, 2, 0.)
1273 flt.setData(chan, 0, 3, loGainDef)
1274 flt.setData(chan, 0, 4, 0.)
1275 flt.setData(chan, 0, 5, 0.)
1276 #=== hi gain defaults
1277 flt.setData(chan, 1, 0, hiPedDef)
1278 flt.setData(chan, 1, 1, hiGainDef)
1279 flt.setData(chan, 1, 2, 0.)
1280 flt.setData(chan, 1, 3, hiGainDef)
1281 flt.setData(chan, 1, 4, 0.)
1282 flt.setData(chan, 1, 5, 0.)
1283
1284 blobWriter.setComment(self.__author,"default noise")
1285 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1286 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1287 except Exception as e:
1288 self.log().critical( e )
1289
1290
1291 #____________________________________________________________________
1292 def writeNoiseAutoCr(self, tag=""):
1293
1294 self.log().info( "*** Writing default sample auto correlation using tag %s", tag)
1295 folder = self.__tilePrefixOfl+"NOISE/AUTOCR"
1296
1297 #=== common noise defaults
1298 default = cppyy.gbl.std.vector('float')()
1299 for i in range(6):
1300 default.push_back(0.)
1301 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1302 defVec.push_back(default)
1303
1304 try:
1305 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
1306 #=== initialize all channels
1307 util = cppyy.gbl.TileCalibUtils()
1308 for ros in range(util.max_ros()):
1309 for drawer in range(util.getMaxDrawer(ros)):
1310 flt = blobWriter.zeroBlob(ros,drawer)
1311 flt = blobWriter.getDrawer(0, 0)
1312 flt.init(defVec,1,0)
1313 blobWriter.setComment(self.__author,"default auto correlation (unit matrix)")
1314 folderTag = TileCalibUtils.getFullTag(folder, tag)
1315 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1316 except Exception as e:
1317 self.log().critical( e )
1318
1319
1320 #____________________________________________________________________
1321 def writeBadChannels(self, tag=""):
1322
1323 self.log().info( "*** Writing BadChannel defaults using tag %s", tag )
1324
1325 default = cppyy.gbl.std.vector('unsigned int')()
1326 default.push_back(0)
1327 defVec = cppyy.gbl.std.vector('std::vector<unsigned int>')()
1328 defVec.push_back(default)
1329
1330 #=== fill offline folder
1331 folders = [self.__tilePrefixOfl+"STATUS/ADC",
1332 self.__tilePrefixOnl+"STATUS/ADC"]
1333
1334 for folder in folders:
1335 try:
1336 multiVers=('OFL' in folder)
1337 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Bch',multiVers)
1338 #=== initialize all channels
1339 util = cppyy.gbl.TileCalibUtils()
1340 for ros in range(util.max_ros()):
1341 for drawer in range(util.getMaxDrawer(ros)):
1342 bch = blobWriter.zeroBlob(ros,drawer)
1343 bch = blobWriter.getDrawer(0, 0)
1344 bch.init(defVec,1,cppyy.gbl.TileBchDecoder.BitPat_ofl01 if multiVers else TileBchDecoder.BitPat_onl01)
1345
1346 blobWriter.setComment(self.__author,"no bad channels")
1347 folderTag = TileCalibUtils.getFullTag(folder, tag) if multiVers else ""
1348 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1349 except Exception as e:
1350 self.log().critical( e )
1351
1352
1353 #____________________________________________________________________
1354 def writePulseShape(self, tag=""):
1355
1356 self.log().info( "*** Writing default pulse shapes with tag %s", tag)
1357
1358
1359 sources = {'PHY' : ( 'pulselo_physics.dat', 'pulsehi_physics.dat', 'TileDefault.plsPhy' ),
1360 'LAS' : ( 'pulselo_laserMax1.dat', 'pulsehi_laserMax1.dat', 'TileDefault.plsLas' ),
1361 'CIS/PULSE100' : ( 'pulselo_cis_100.dat', 'pulsehi_cis_100.dat', 'TileDefault.plsCisPulse100'),
1362 'CIS/PULSE5P2' : ( 'pulselo.0230055.12.cap.5.2.dat', 'pulsehi.0230055.12.cap.5.2.dat', 'TileDefault.plsCisPulse5p2'),
1363 'CIS/LEAK100' : ( 'leaklo_100.dat', 'leakhi_100.dat', 'TileDefault.plsCisLeak100'),
1364 'CIS/LEAK5P2' : ( 'leaklo.0230055.12.cap.5.2.dat', 'leakhi.0230055.12.cap.5.2.dat', 'TileDefault.plsCisLeak5p2')
1365 }
1366
1367
1368 for source, info in list(sources.items()):
1369
1370 path = pathDef
1371
1372 #=== read in low gain pulse shape
1373 xlo = []
1374 ylo = []
1375 lines = open(path+info[0],"r").readlines()
1376 for line in lines:
1377 fields = line.strip().split()
1378 #=== ignore empty and comment lines
1379 if not len(fields) :
1380 continue
1381 if fields[0].startswith("#"):
1382 continue
1383 if fields[0].startswith("*"):
1384 continue
1385 if len(fields) != 2 :
1386 continue
1387
1388 xlo.append(float(fields[0]))
1389 ylo.append(float(fields[1]))
1390
1391 #=== read in high gain pulse shape
1392 xhi = []
1393 yhi = []
1394 lines = open(path+info[1],"r").readlines()
1395 for line in lines:
1396 fields = line.strip().split()
1397 #=== ignore empty and comment lines
1398 if not len(fields) :
1399 continue
1400 if fields[0].startswith("#"):
1401 continue
1402 if fields[0].startswith("*"):
1403 continue
1404 if len(fields) != 2 :
1405 continue
1406
1407 xhi.append(float(fields[0]))
1408 yhi.append(float(fields[1]))
1409
1410 #=== create default ascii file
1411 fileStr = "OBJVERSION 200"
1412 fileStr+= "\n0x000\t0\t0\t"
1413 for x in xlo:
1414 fileStr += "%f " % x
1415 for y in ylo:
1416 fileStr += "%f " % y
1417 fileStr+= "\n0x000\t0\t1\t"
1418 for x in xhi:
1419 fileStr += "%f " % x
1420 for y in yhi:
1421 fileStr += "%f " % y
1422 fileStr+="\n"
1423 defFile = open(info[2],"w")
1424 defFile.write(fileStr)
1425 defFile.close()
1426
1427 #=== build default pulseshape vectors for db
1428 defaultLo = cppyy.gbl.std.vector('float')()
1429 for x in xlo:
1430 defaultLo.push_back(x)
1431 for y in ylo:
1432 defaultLo.push_back(y)
1433 defaultHi = cppyy.gbl.std.vector('float')()
1434 for x in xhi:
1435 defaultHi.push_back(x)
1436 for y in yhi:
1437 defaultHi.push_back(y)
1438 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1439 defVec.push_back(defaultLo)
1440 defVec.push_back(defaultHi)
1441 try:
1442 folder = self.__tilePrefixOfl+"PULSESHAPE/"+source
1443 blobWriter = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt')
1444 #=== initialize all channels
1445 util = cppyy.gbl.TileCalibUtils()
1446 for ros in range(util.max_ros()):
1447 for drawer in range(util.getMaxDrawer(ros)):
1448 blobWriter.zeroBlob(ros,drawer)
1449
1450 #=== default for detector
1451 det = blobWriter.getDrawer(0, 0)
1452 det.init(defVec,1,200)
1453
1454 blobWriter.setComment(self.__author,"default pulse shapes")
1455 folderTag = TileCalibUtils.getFullTag(folder, tag)
1456 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1457
1458 except Exception as e:
1459 self.log().critical( e )
1460
1461
1462 #____________________________________________________________________
1463 def writeMuonReceiverPulseShape(self, tag = ""):
1464
1465 self.log().info( "*** Writing default pulse shapes for TileMuonReceiver board with tag %s", tag)
1466
1467 folder_name = 'MURCV'
1468 source_file = 'pulse_adder_muonRcv_physics.dat'
1469 output_file = 'TileDefault.plsMuRcv'
1470
1471 path = pathDef
1472
1473 #=== read pulse shape
1474 phases = []
1475 amplitudes = []
1476 lines = open(path + source_file,"r").readlines()
1477 for line in lines:
1478 fields = line.strip().split()
1479 #=== ignore empty and comment lines
1480 if not len(fields) :
1481 continue
1482 if fields[0].startswith("#"):
1483 continue
1484 if fields[0].startswith("*"):
1485 continue
1486 if len(fields) != 2 :
1487 continue
1488
1489 phases.append(float(fields[0]))
1490 amplitudes.append(float(fields[1]))
1491
1492 #=== create default ascii file
1493 fileStr = "OBJVERSION 200"
1494 fileStr += "\n0x000\t0\t0\t"
1495 for phase in phases:
1496 fileStr += "%f " % phase
1497 for amplitude in amplitudes:
1498 fileStr += "%f " % amplitude
1499 fileStr += "\n"
1500 defFile = open(output_file,"w")
1501 defFile.write(fileStr)
1502 defFile.close()
1503
1504 #=== build default pulseshape vectors for db
1505 defaultPls = cppyy.gbl.std.vector('float')()
1506 for phase in phases:
1507 defaultPls.push_back(phase)
1508 for amplitude in amplitudes:
1509 defaultPls.push_back(amplitude)
1510 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1511 defVec.push_back(defaultPls)
1512 try:
1513 folder = self.__tilePrefixOfl + "PULSESHAPE/" + folder_name
1514 blobWriter = TileCalibTools.TileBlobWriter(self.__db, folder, 'Flt')
1515 #=== initialize all channels
1516 util = cppyy.gbl.TileCalibUtils()
1517 for ros in range(util.max_ros()):
1518 for drawer in range(util.getMaxDrawer(ros)):
1519 blobWriter.zeroBlob(ros,drawer)
1520
1521 #=== default for detector
1522 det = blobWriter.getDrawer(0, 0)
1523 det.init(defVec,1,200)
1524
1525 blobWriter.setComment(self.__author, "default pulse shape for tile muon receiver board")
1526 folderTag = TileCalibUtils.getFullTag(folder, tag)
1527 blobWriter.register((MINRUN,MINLBK),(MAXRUN,MAXLBK),folderTag)
1528
1529 except Exception as e:
1530 self.log().critical( e )
1531
1532
1533 #____________________________________________________________________
1534 def writeMuid(self):
1535
1536 self.log().info( "*** Writing default Muid thresholds" )
1537
1538 """
1539 The TileMuId algorythm runs in DSPs and requires up to 40 energy cuts
1540 per module (in barrel, in extended barrel it is less). These 40 numbers
1541 are 20 pairs of lower ad upper energy cuts for 20 cells in the module.
1542 The values are stored as a vector of 40 numbers at channel 0 of every module.
1543 """
1544
1545 #=== construct folder path
1546 folder = self.__tilePrefixOnl+"MUID"
1547
1548 #=== common TileMuId defaults
1549 default = cppyy.gbl.std.vector('float')()
1550 for i in range(20):
1551 default.push_back(150.)
1552 default.push_back(5000.)
1553 defVec = cppyy.gbl.std.vector('std::vector<float>')()
1554 defVec.push_back(default)
1555 defVec.push_back(default)
1556
1557 #=== get a writer
1558 writer = TileCalibTools.TileBlobWriter(self.__db,folder,'Flt',False)
1559 writer.setComment(self.__author,"TileMuId default values")
1560
1561 #=== initialize all channels and write global default
1562 util = cppyy.gbl.TileCalibUtils()
1563 for ros in range(util.max_ros()):
1564 for drawer in range(util.getMaxDrawer(ros)):
1565 writer.zeroBlob(ros,drawer)
1566 calibDrawer = writer.getDrawer(0,0)
1567 calibDrawer.init(defVec,1,1)
1568
1569 #=== register in DB
1570 writer.register((MINRUN,MINLBK),(MAXRUN,MAXLBK), "")
debug
const bool debug
Definition MakeUncertaintyPlots.cxx:53
pow
constexpr int pow(int base, int exp) noexcept
Definition ap_fixedTest.cxx:15
TileCalibUtils::getFullTag
static std::string getFullTag(const std::string &folder, const std::string &tag)
Returns the full tag string, composed of camelized folder name and tag part.
Definition TileCalibUtils.cxx:33
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeNoiseSample
writeNoiseSample(self, tag="", loGainDef=0.8, hiGainDef=1.6)
Definition TileCalibDefaultWriter.py:1093
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeCis
writeCis(self, tag="", loGainDef=(1023./800.), hiGainDef=(64.*1023./800.))
Definition TileCalibDefaultWriter.py:73
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeNoiseOnl
writeNoiseOnl(self, tag="", loGainDef=0.8, hiGainDef=1.6)
Definition TileCalibDefaultWriter.py:1174
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeNoiseFit
writeNoiseFit(self, tag="", loGainDef=0.8, hiGainDef=1.6)
Definition TileCalibDefaultWriter.py:1054
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeCes
writeCes(self, tag="", Simulation=True, MBTSflag="7TeV", dCellWeight=1.2, eCellWeight=1.5, since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK), mode='DEFAULT')
Definition TileCalibDefaultWriter.py:240
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeEmscaleMC
writeEmscaleMC(self, tag="", emscale=(1.05/1000.), since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK))
Definition TileCalibDefaultWriter.py:817
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeNoiseSampleMC
writeNoiseSampleMC(self, tag="", loGainDef=0.8, hiGainDef=1.6)
Definition TileCalibDefaultWriter.py:1215
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeOldCes
writeOldCes(self, tag="", dCellWeight=1.2, eCellWeight=1.5, since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK))
Definition TileCalibDefaultWriter.py:581
python.TileCalibDefaultWriter.TileCalibDefaultWriter.writeEmscale
writeEmscale(self, tag="", since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK))
Definition TileCalibDefaultWriter.py:721
split
std::vector< std::string > split(const std::string &s, const std::string &t=":")
Definition hcg.cxx:177
Generated on for ATLAS Offline Software by doxygen 1.14.0