00001 #!/usr/local/bin/python
00002 #
00003 # Copyright 2003
00004 # by
00005 # The Board of Trustees of the
00006 # Leland Stanford Junior University.
00007 # All rights reserved.
00008 #
00009
00010
00011 __facility__ = "Online"
00012 __abstract__ = "LDF Interface for standardPlotter"
00013 __author__ = "Lester Miller"
00014 __date__ = "11/18/2003"
00015 __version__ = "$Revision: 1.7 $"
00016 __credits__ = "SLAC"
00017
00018 import LATTE.copyright_SLAC
00019 import LDF
00020 import Numeric as numarray
00021 import time
00022
00023 class LATcomponentIterator(LDF.LATcomponentIterator):
00024 def __init__(self):
00025 LDF.LATcomponentIterator.__init__(self)
00026 self.eventMarker = None
00027 self.ntDefinitions = self.declareNtDefinitions()
00028 self.ntDescriptions = self.declareNtDescriptions()
00029 # protect against failure to have dictionaries and pedestals
00030 self.ntDict = {}
00031 self.numarrayDict = {}
00032 self.acdPeds = None
00033 self.calPeds = None
00034 self.sparsify = False
00035 # other needed internal variables
00036 self.nEvtSeen = 0
00037 self.prevPpcTime = 0
00038 self.prevGmTime = 0
00039 self.markerPpcTime = 0
00040 self.markerGmTime = 0
00041 self.ppcTimeInSec = 0.
00042 self.gemTimeInSec = 0.
00043 self.prevGemTime = 0.
00044 self.collectingPedestals = False
00045
00046 def UDFcomponent(self, event, ebfContribution):
00047 return 0
00048
00049 def OSWcomponent(self, event, oswContribution):
00050 oswContribIter = OSWcontributionIterator(event, oswContribution, self)
00051 oswContribIter.iterate()
00052 self.nEvtSeen+=1
00053 return 0
00054
00055 def ACDcomponent(self, event, aemContribution):
00056 acdContrib = AEMcontributionIterator(event, aemContribution, self)
00057 acdContrib.fill()
00058 return 0
00059
00060 def GEMcomponent(self, event, gemContribution):
00061 gemContrib = GEMcontribution(event, gemContribution, self)
00062 gemContrib.fill()
00063 return 0
00064
00065 def CALcomponent(self, event, calContribution):
00066 calContrib = CALcontributionIterator(event, calContribution, self)
00067 calContrib.fill()
00068 return 0
00069
00070 def TKRcomponent(self, event, tkrContribution):
00071 tkrContrib = TKRcontributionIterator(event, tkrContribution, self)
00072 tkrContrib.fill()
00073 return 0
00074
00075 def diagnostic(self, event, contribution):
00076 if not LDF.EventSummary.diagnostic(contribution.summary()):
00077 return
00078 diagContrib = DIAGcontributionIterator(event,contribution,self.TKRend(),self)
00079 diagContrib.iterateCAL()
00080 diagContrib.iterateTKR()
00081 self.diagnosticEnd(self.TKRend() + diagContrib.size())
00082 return 0
00083
00084 def error(self, event, contribution):
00085 if not LDF.EventSummary.error(contribution.summary()):
00086 return
00087 if self.diagnosticEnd() != 0:
00088 offset=self.diagnosticEnd()
00089 else:
00090 offset=self.TKRend()
00091 errorContrib = LDF.ERRcontributionIterator(event,contribution,offset)
00092 theError = errorContrib.theError()
00093 if 'evt_error' in self.ntDict:
00094 cRow = [0,theError.tmo(),theError.phs(),theError.cal()<<8|theError.tkr(),self.ppcTimeInSec]
00095 cNt = self.ntDict['evt_error']
00096 cNt.addRow(cRow)
00097 self.errorEnd(offset + errorContrib.size())
00098 return 0
00099
00100 def getEventMarker(self):
00101 return self.eventMarker
00102
00103 def declareNtDefinitions(self):
00104 definitions = {}
00105 definitions['osw_time'] = ["eventnum","evtsize","dtppc","gmtime","ppctime"]
00106 definitions['tkr_trig'] = ["tower", "layer", "end","chanindex","ppctime"]
00107 definitions['tkr_hit'] = ["tower", "layer", "fenum", "hit","chanindex","ppctime"]
00108 definitions['tkr_tot'] = ["tower", "layer", "end", "tot","chanindex","ppctime"]
00109 definitions['tkr_layer'] = ["tower", "layer", "nhit","chanindex","ppctime"]
00110 definitions['cal_trig'] = ["tower", "layer", "end", "le", "he","chanindex","ppctime"]
00111 definitions['cal_lac'] = ["tower", "layer", "col", "end","lac","chanindex","ppctime"]
00112 definitions['cal_accept']= ["tower", "layer", "col", "end","adc","chanindex","ppctime"]
00113 definitions['cal_log'] = ["tower", "layer", "col", "adcp", "adcn", "adcmean", "adcdiff","chanindex","ppctime"]
00114 definitions['acd_hit'] = ["arc", "afe", "tile", "side","chanindex","ppctime"]
00115 definitions['acd_accept']= ["arc", "afe", "tile", "side", "pha","chanindex","ppctime"]
00116 definitions['acd_tile'] = ["tile", "pha1", "pha2", "phamean", "phadiff", "hit1", "hit2", "hitor","chanindex","ppctime"]
00117 definitions['gem_event'] = ["dtreg", "dtcalc", "condsum", "ntile", "live", "gtime", "prescale", "discarded", "sent","ppctime"]
00118 definitions['gem_input'] = ["cno","tileXY","tileXZM","tileXZP","tileYZM","tileYZP","tileRBN","tileNA","roi", "tkr", "callo", "calhe","ppctime"]
00119 definitions['evt_error'] = ["tower", "phasing", "timeout","cc","ppctime"]
00120 return definitions
00121
00122 def declareNtDescriptions(self):
00123 descriptions = {}
00124 descriptions['osw_time'] = ["Event Number","Event Size","PPC Delta t","G.M. time","PPC time"]
00125 descriptions['tkr_trig'] = ["Tower", "Layer (0-35)", "End","Channel: Tower, Layer(0-35), End(0-1)","PPC time"]
00126 descriptions['tkr_hit'] = ["Tower", "Layer (0-35)", "TFE number (0-23)", "Strip Number","Channel: Tower, Layer (0-35), TFE (0-23)","PPC time"]
00127 descriptions['tkr_tot'] = ["Tower", "Layer (0-35)", "End", "TOT","Channel: Tower, Layer(0-35), End(0-1)","PPC time"]
00128 descriptions['tkr_layer'] = ["Tower", "Layer (0-35)", "Number Strips Hit","Layer: Tower, Layer(0-35)","PPC time"]
00129 descriptions['cal_trig'] = ["Tower", "Layer", "End", "FLE fired", "FHE fired","Channel: Tower, Layer(0-7), End(0-1)","PPC time"]
00130 descriptions['cal_lac'] = ["Tower", "Layer", "Column", "End","LAC fired","Channel: Tower, Layer(0-7), Column(0-11), End(0-1)","PPC time"]
00131 descriptions['cal_accept']= ["Tower", "Layer", "Column", "End","ADC Value","Channel: Tower, Layer(0-7), Column(0-11), End(0-1)","PPC time"]
00132 descriptions['cal_log'] = ["Tower", "Layer", "Column", "ADC+", "ADC-", "ADC Mean", "ADC Relative Difference","Log: Tower, Layer(0-7), Column(0-11)","PPC time"]
00133 descriptions['acd_hit'] = ["ARC (cable)", "AFE (channel)", "Tile Number", "Tile Side","Channel: Tile (0-107), Side(0-1)","PPC time"]
00134 descriptions['acd_accept']= ["ARC (cable)", "AFE (channel)", "Tile Number", "Tile Side","ADC Value","Channel: Tile Number(0-107), Side(0-1)","PPC time"]
00135 descriptions['acd_tile'] = ["Tile Number", "ADC Side A", "ADC Side B", "ADC Mean", "ADC Relative Difference", "Veto A Fired", "Veto B Fired", "Veto Fired","Channel: Tile (0-107)","PPC time"]
00136 descriptions['gem_event'] = ["Delta T Register", "Delta T Calculated", "Condition Summary", "Number Tiles Fired", "Live Time", "Gem Time", "Prescaled Register", "Discarded Register", "Sent Register","PPC time"]
00137 descriptions['gem_input'] = ["CNO Vector","ACD Tile XY","ACD Tile XZ-","ACD tile XZ+","ACD Tile YZ-","ACD Tile YZ+","ACD Fiber","ACD NA","Roi Vector", "Tkr Vector", "Cal Low Vector", "Cal High Vector","PPC time"]
00138 descriptions['evt_error'] = ["Tower", "Phasing Error bit", "Timeout bit","CC Bit Field","PPC time"]
00139 return descriptions
00140
00141 def getColumnDescription(self,ntName,columnName):
00142 index = 0
00143 result = ''
00144 if ntName not in self.ntDefinitions or ntName not in self.ntDescriptions:
00145 return result
00146 descriptionList = self.ntDescriptions[ntName]
00147 for column in self.ntDefinitions[ntName]:
00148 if column == columnName:
00149 result = descriptionList[index]
00150 index+=1
00151 return result
00152
00153 def getChanIndexDescription(self,ntName,value):
00154 result = 'chanindex'
00155 if ntName == 'cal_accept':
00156 tower = value/(8*12*2)
00157 value = value%(8*12*2)
00158 layer = value/(12*2)
00159 value = value%(12*2)
00160 column = value/(2)
00161 value = value%(2)
00162 end = value
00163 result = 'Tower %d Layer %d Column %d End %d'%(tower,layer,column,end)
00164 if ntName == 'cal_log':
00165 tower = value/(8*12)
00166 value = value%(8*12)
00167 layer = value/(12)
00168 value = value%(12)
00169 column = value
00170 result = 'Tower %d Layer %d Column %d'%(tower,layer,column)
00171 if ntName == 'cal_lac':
00172 tower = value/(8*12*2)
00173 value = value%(8*12*2)
00174 layer = value/(12*2)
00175 value = value%(12*2)
00176 column = value/(2)
00177 value = value%(2)
00178 end = value
00179 result = 'Tower %d Layer %d Column %d End %d'%(tower,layer,column,end)
00180 if ntName == 'cal_trig':
00181 tower = value/(8*2)
00182 value = value%(8*2)
00183 layer = value/(2)
00184 value = value%(2)
00185 end = value
00186 result = 'Tower %d Layer %d End %d'%(tower,layer,end)
00187
00188 if ntName == 'tkr_layer':
00189 tower = value/(36)
00190 value = value%(36)
00191 layer = value
00192 result = 'Tower %d Layer %d'%(tower,layer)
00193 if ntName == 'tkr_hit':
00194 tower = value/(36*24)
00195 value = value%(36*24)
00196 layer = value/(24)
00197 value = value%(24)
00198 fenum = value
00199 result = 'Tower %d Layer %d TFE %d'%(tower,layer,fenum)
00200 if ntName == 'tkr_tot':
00201 tower = value/(36*2)
00202 value = value%(36*2)
00203 layer = value/(2)
00204 value = value%(2)
00205 end = value
00206 result = 'Tower %d Layer %d End %d'%(tower,layer,end)
00207 if ntName == 'tkr_trig':
00208 tower = value/(36*2)
00209 value = value%(36*2)
00210 layer = value/(2)
00211 value = value%(2)
00212 end = value
00213 result = 'Tower %d Layer %d End %d'%(tower,layer,end)
00214
00215 if ntName == 'acd_accept':
00216 tileRemap = value/(2)
00217 value = value%(2)
00218 side = value
00219 tile = self.getTileNumber(int(tileRemap))
00220 result = 'Tile %d Side %d'%(tile,side)
00221 if ntName == 'acd_tile':
00222 tileRemap = value
00223 tile = self.getTileNumber(int(tileRemap))
00224 result = 'Tile %d'%(tile)
00225 return result
00226
00227 def getTileNumber(self,remapTileNumber):
00228 # remap: top has 25, sides 16, 8 fibers and last 11 unassigned
00229 # three digits of tilenumber are [side][xcoord][yxoord]
00230 result = None
00231 if remapTileNumber<25:
00232 result = 10*(remapTileNumber/5) + remapTileNumber%5
00233 elif remapTileNumber<(25+4*16):
00234 result = 100+100*((remapTileNumber-25)/16)
00235 remainder = (remapTileNumber-25)%16
00236 result += 10*(remainder/5) + remapTileNumber%5
00237 elif remapTileNumber<(25+4*16+8):
00238 division = (remapTileNumber-25-4*16)/4
00239 remainder = (remapTileNumber-25-4*16)%4
00240 result = 500+100*division+10*remainder
00241 else:
00242 result = 700+(remapTileNumber-25-4*16-8)
00243 return result
00244
00245 def getNtupleDefinition(self,ntName):
00246 # this returns the string of column names if it is known of here
00247 if ntName in self.ntDefinitions:
00248 return self.ntDefinitions[ntName]
00249 else:
00250 return None
00251
00252 class CALcontributionIterator(LDF.CALcontributionIterator):
00253 def __init__(self, event, contribution,lci):
00254 LDF.CALcontributionIterator.__init__(self, event, contribution)
00255 self.lci = lci
00256
00257 def fill(self):
00258 length = self.contribution().numLogAccepts()
00259 if length == 0:
00260 return
00261 self.iterate()
00262
00263 def log(self, tower, layer, theLog):
00264 column = theLog.column()
00265 positive = theLog.positive()
00266 negative = theLog.negative()
00267 posRange = positive.range()
00268 posValue = positive.value()
00269 negRange = negative.range()
00270 negValue = negative.value()
00271 if self.lci.calPeds is not None:
00272 posValue -= self.lci.calPeds[tower,layer,column,0,posRange,0]
00273 negValue -= self.lci.calPeds[tower,layer,column,1,negRange,0]
00274 # to translate from range to range, lo to hi is 8, with area between diodes of 6
00275 rangeMultiplier = [1.,8.,6.*8.,6.*8.*8.]
00276 posValue *= rangeMultiplier[posRange]
00277 negValue *= rangeMultiplier[negRange]
00278 # until I decide to get four range pedestals, this will kludge
00279 if posRange>0: posValue = 4096.
00280 if negRange>0: negValue = 4096.
00281 negRange = 0
00282 posRange = 0
00283 if self.lci.sparsify:
00284 if negValue < 3.*self.lci.calPeds[tower,layer,column,0,posRange,1]:
00285 negValue = None
00286 if posValue < 3.*self.lci.calPeds[tower,layer,column,1,posRange,1]:
00287 posValue = None
00288 else:
00289 # can't relate ranges without peds so just fill overflow for other ranges
00290 if not self.lci.collectingPedestals:
00291 if posRange>0: posValue = 4096.
00292 if negRange>0: negValue = 4096.
00293 if 'cal_accept' in self.lci.ntDict:
00294 cNt = self.lci.ntDict['cal_accept']
00295 if negValue is not None:
00296 chanIndex = tower*8*12*2 + layer*12*2 + column*2
00297 cRow = [tower,layer,column,0,negValue,chanIndex,self.lci.ppcTimeInSec]
00298 cNt.addRow(cRow)
00299 if posValue is not None:
00300 chanIndex = tower*8*12*2 + layer*12*2 + column*2 + 1
00301 cRow = [tower,layer,column,1,posValue,chanIndex,self.lci.ppcTimeInSec]
00302 cNt.addRow(cRow)
00303 if 'cal_log' in self.lci.numarrayDict:
00304 cNumarray = self.lci.numarrayDict['cal_log']
00305 if negValue is not None:
00306 cNumarray[tower,layer,column,0,negRange] = negValue
00307 if posValue is not None:
00308 cNumarray[tower,layer,column,1,posRange] = posValue
00309 if posValue is None or negValue is None:
00310 return
00311 average = (posValue+negValue)/2.
00312 if average!=0:
00313 difference = (posValue-negValue)/(2.*average)
00314 else:
00315 difference = 0
00316 if 'cal_log' in self.lci.ntDict:
00317 cNt = self.lci.ntDict["cal_log"]
00318 chanIndex = tower*8*12 + layer*12 + column
00319 cRow = [tower,layer,column,posValue,negValue,average,difference,chanIndex,self.lci.ppcTimeInSec]
00320 cNt.addRow(cRow)
00321
00322 class TKRcontributionIterator(LDF.TKRcontributionIterator):
00323 def __init__(self, event, contribution, lci):
00324 LDF.TKRcontributionIterator.__init__(self, event, contribution)
00325 self.lci = lci
00326 self.__debug = 0
00327
00328 def fill(self):
00329 length = self.contribution().numAccepts(self.event())
00330 if length == 0:
00331 return
00332 self.layerHits = [0] * 16 * 36
00333 self.iterateStrips()
00334 self.iterateTOTs()
00335 # fill layer hits ntuple
00336 if 'tkr_layer' in self.lci.ntDict:
00337 cNt = self.lci.ntDict['tkr_layer']
00338 for tower in range(16):
00339 for layer in range(36):
00340 chanIndex = tower*36+layer
00341 if self.layerHits[chanIndex]>0:
00342 cRow = [tower,layer,self.layerHits[layer],chanIndex,self.lci.ppcTimeInSec]
00343 cNt.addRow(cRow)
00344
00345 def strip(self, tower, layerEnd, hit):
00346 layer = layerEnd >> 1
00347 fenum = int(hit/64)
00348 self.layerHits[tower*36+layer]+=1;
00349 if 'tkr_hit' in self.lci.ntDict:
00350 cNt = self.lci.ntDict['tkr_hit']
00351 chanIndex = tower*36*24+layer*24+fenum
00352 cRow = [tower,layer,fenum,hit,chanIndex,self.lci.ppcTimeInSec]
00353 cNt.addRow(cRow)
00354
00355 def TOT(self, tower, layerEnd, tot):
00356 layer = layerEnd>>1
00357 end = layerEnd%2
00358 if 'tkr_tot' in self.lci.ntDict:
00359 cNt = self.lci.ntDict['tkr_tot']
00360 chanIndex = tower*36*2+layer*2+end
00361 cRow = [tower,layer,end,tot,chanIndex,self.lci.ppcTimeInSec]
00362 cNt.addRow(cRow)
00363
00364 class AEMcontributionIterator(LDF.AEMcontributionIterator):
00365 def __init__(self,event,contribution, lci):
00366 LDF.AEMcontributionIterator.__init__(self,event,contribution)
00367 self.lci = lci
00368 def fill(self):
00369 if 'acd_tile' in self.lci.ntDict:
00370 self.acdAdc0 = {}
00371 self.acdAdc1 = {}
00372 self.acdHit0 = {}
00373 self.acdHit1 = {}
00374 self.iterate()
00375 if 'acd_tile' in self.lci.ntDict:
00376 for tileNumber in self.acdAdc0.keys():
00377 pha0 = self.acdAdc0[tileNumber]
00378 pha1 = self.acdAdc1[tileNumber]
00379 hit0=0
00380 hit1=0
00381 if tileNumber in self.acdHit0:
00382 hit0 = self.acdHit0[tileNumber]
00383 if hit0 is None:
00384 hit0 = 0
00385 if tileNumber in self.acdHit1:
00386 hit1 = self.acdHit1[tileNumber]
00387 if hit1 is None:
00388 hit1 = 0
00389 if pha0 is not None and pha1 is not None:
00390 # have both read out so make it a tile...
00391 average = (pha0+pha1)/2.
00392 if average!=0:
00393 difference = (pha0-pha1)/(2.*average)
00394 else:
00395 difference = 0
00396 cNt = self.lci.ntDict['acd_tile']
00397 chanIndex = self.getRemappedTileNumber(tileNumber)
00398 cRow = [tileNumber,pha0,pha1,average,difference,hit0,hit1,hit0|hit1,chanIndex,self.lci.ppcTimeInSec]
00399 cNt.addRow(cRow)
00400
00401 def header(self, cable, hdr):
00402 for channel in range(18):
00403 if (hdr.hitMap()>>channel)&0x1:
00404 tileNumber = self.getMiniAcdTileNumber(cable,channel)
00405 remappedTileNumber = self.getRemappedTileNumber(tileNumber)
00406 side = self.getMiniAcdSide(cable,channel)
00407 if 'acd_hit' in self.lci.ntDict:
00408 cNt = self.lci.ntDict['acd_hit']
00409 chanIndex = remappedTileNumber*2+side
00410 cRow = [cable,channel,tileNumber,side,chanIndex,self.lci.ppcTimeInSec]
00411 cNt.addRow(cRow)
00412 if 'acd_tile' in self.lci.ntDict:
00413 if side==0:
00414 self.acdHit0[tileNumber]=1
00415 if not tileNumber in self.acdHit1:
00416 self.acdHit1[tileNumber]=None
00417 if side==1:
00418 self.acdHit1[tileNumber]=1
00419 if not tileNumber in self.acdHit0:
00420 self.acdHit0[tileNumber]=None
00421
00422 def pha(self, cable, channel, p):
00423 adcValue = p.ADCvalue()
00424 adcRange = p.ADCrange()
00425 if self.lci.acdPeds is not None:
00426 adcValue -= self.lci.acdPeds[cable,channel,p.ADCrange(),0]
00427 rangeMultiplier = [1.,100.]
00428 adcValue*=rangeMultiplier[p.ADCrange()]
00429 # until second range pedestals are available, just overflow the other range
00430 if adcRange>0: adcValue = 4096.
00431 adcRange = 0
00432 if self.lci.sparsify:
00433 if adcValue < 3.*self.lci.acdPeds[cable,channel,adcRange,1]:
00434 return # don't fill if we're sparsifying
00435 else:
00436 # overflow the second range if no pedestals
00437 if not self.lci.collectingPedestals:
00438 if adcRange>0: adcValue = 4096.
00439 tileNumber = self.getMiniAcdTileNumber(cable,channel)
00440 remapTileNumber = self.getRemappedTileNumber(tileNumber)
00441 # side
00442 side = self.getMiniAcdSide(cable,channel)
00443 if 'acd_accept' in self.lci.ntDict:
00444 cNt = self.lci.ntDict["acd_accept"]
00445 chanIndex = remapTileNumber*2+side
00446 cRow = [cable,channel,tileNumber,side,adcValue,chanIndex,self.lci.ppcTimeInSec]
00447 cNt.addRow(cRow)
00448 if 'acd_tile' in self.lci.ntDict:
00449 if side==0:
00450 self.acdAdc0[tileNumber]=adcValue
00451 if not tileNumber in self.acdAdc1:
00452 self.acdAdc1[tileNumber]=None
00453 if side==1:
00454 self.acdAdc1[tileNumber]=adcValue
00455 if not tileNumber in self.acdAdc0:
00456 self.acdAdc0[tileNumber]=None
00457 if 'acd_pha' in self.lci.numarrayDict:
00458 cNumarray = self.lci.numarrayDict["acd_pha"]
00459 cNumarray[cable,channel,adcRange] = adcValue
00460
00461 def getSide(self,cable,channel):
00462 id = self.event().identity()
00463 tbl = self.map().lookup(id, cable, channel)
00464 if tbl.a() == 'A':
00465 side = 0
00466 else:
00467 side = 1
00468 return side
00469
00470 def getIntegerTileNumber(self,cable,channel):
00471 id = self.event().identity()
00472 tbl = self.map().lookup(id, cable, channel)
00473 tileName = tbl.name()
00474 if tileName[0:2] == 'NA':
00475 tileNumber = int(tileName[2:])
00476 tileNumber += 700
00477 else:
00478 tileNumber = int(tileName)
00479 return tileNumber
00480
00481 def getMiniAcdSide(self,cable,channel):
00482 # special kludged version for miniAcd
00483 id = self.event().identity()
00484 tbl = self.map().lookup(id, cable, channel)
00485 if tbl.a() == 'A':
00486 side = 0
00487 else:
00488 side = 1
00489
00490 # special remaps
00491 if cable==10 and channel==6:
00492 side = 1
00493 if cable==10 and channel==7:
00494 side = 1
00495 if cable==10 and channel==11:
00496 side = 0
00497 if cable==10 and channel==12:
00498 side = 0
00499
00500 return side
00501
00502 def getMiniAcdTileNumber(self,cable,channel):
00503 # special kludged version for miniAcd
00504 id = self.event().identity()
00505 tbl = self.map().lookup(id, cable, channel)
00506 tileName = tbl.name()
00507 if tileName[0:2] == 'NA':
00508 tileNumber = int(tileName[2:])
00509 tileNumber += 700
00510 else:
00511 tileNumber = int(tileName)
00512
00513 # special remaps
00514 if cable==10 and channel==6:
00515 tileNumber = 0
00516 if cable==10 and channel==7:
00517 tileNumber = 1
00518 if cable==10 and channel==11:
00519 tileNumber = 0
00520 if cable==10 and channel==12:
00521 tileNumber = 1
00522
00523 return tileNumber
00524
00525 def getRemappedTileNumber(self,tileNumber):
00526 # remap: top has 25, sides 16, 8 fibers and last 11 unassigned
00527 # three digits of tilenumber are [side][xcoord][yxoord]
00528 remainder = tileNumber%100
00529 division = tileNumber/100
00530 remapTileNumber = 5*(remainder/10)+remainder%10
00531 if division>=1 and division<5:
00532 remapTileNumber+=25+16*(division-1)
00533 elif division==5 or division==6:
00534 remapTileNumber=25+16*4+(remainder/10)
00535 elif division==7:
00536 remapTileNumber=25+16*4+8+remainder
00537 return remapTileNumber
00538
00539 class OSWcontributionIterator(LDF.OSWcontributionIterator):
00540 def __init__(self, event, contribution, lci):
00541 LDF.OSWcontributionIterator.__init__(self, event, contribution)
00542 self.lci = lci
00543 # these are for filling ntuple (in OSWtime)
00544 self.eventNumber = LDF.EventSummary.eventNumber(event.summary())*4+LDF.EventSummary.tag(event.summary())
00545 self.eventSize = event.length()
00546 # marker is kept by the lci for access from scripts
00547 self.lci.eventMarker = LDF.EventSummary.marker(event.summary())
00548
00549 def OSWtime(self, timeStamp, timebase):
00550 ts = LDF.OSWtimeSpec(timeStamp)
00551 gmTime = ts.sec()+1.e-9*ts.nsec()
00552 # get around the sign bit problem
00553 lowerTime = long(timebase.lower())
00554 if lowerTime<0: lowerTime += 0x100000000L-1
00555 upperTime = long(timebase.upper())
00556 if upperTime<0: upperTime += 0x100000000L-1
00557 ppcTime = upperTime<<32 | lowerTime
00558 if self.lci.eventMarker==5:
00559 self.lci.markerPpcTime = ppcTime
00560 self.lci.markerGmTime = gmTime
00561 # convert to seconds since marker for ntuple
00562 # at 64 bits don't have to worry about rolling over...
00563 dtPpc = 0.
00564 if self.lci.prevPpcTime!=0:
00565 dtPpc = ppcTime - self.lci.prevPpcTime
00566 dtPpcInSec = (1.*dtPpc)/20.e6
00567 ppcTimeInSec = 1.*(ppcTime - self.lci.markerPpcTime)/20.e6
00568 gmTimeInSec = 1.*(gmTime - self.lci.markerGmTime)
00569 self.lci.ppcTimeInSec = ppcTimeInSec
00570 if 'osw_time' in self.lci.ntDict:
00571 cRow = [self.eventNumber,self.eventSize,dtPpcInSec,gmTimeInSec,ppcTimeInSec]
00572 cNt = self.lci.ntDict['osw_time']
00573 cNt.addRow(cRow)
00574 self.lci.prevPpcTime = ppcTime
00575 self.lci.prevGmTime = gmTime
00576 return 0
00577
00578 def OSW_UDF(self, event, contribution):
00579 return 0
00580
00581 class DIAGcontributionIterator(LDF.DIAGcontributionIterator):
00582 __gtccEndMap = [0,1,1,0,1,0,0,1]
00583 __gtccLayerStart= [0,0,1,1,3,3,2,2]
00584 def __init__(self,event,contribution,dataStart,lci):
00585 LDF.DIAGcontributionIterator.__init__(self,event,contribution)
00586 self.offset(dataStart) # Set the start of the diagnostic data
00587 self.lci=lci
00588
00589 def CALdiag(self, tower, layer, diag):
00590 if 'cal_lac' in self.lci.ntDict:
00591 cNt = self.lci.ntDict['cal_lac']
00592 for column in range(12):
00593 for end in range(2):
00594 lac = (diag.logAccepts(end)>>column)&0x1
00595 if lac:
00596 realEnd = (end+1)%2
00597 chanIndex = tower*8*12*2 + layer*12*2 + column*2 + realEnd
00598 cRow = [tower,layer,column,realEnd,lac,chanIndex,self.lci.ppcTimeInSec]
00599 cNt.addRow(cRow)
00600 if 'cal_trig' in self.lci.ntDict:
00601 cNt = self.lci.ntDict['cal_trig']
00602 for end in range(2):
00603 le = diag.low(end)
00604 he = diag.high(end)
00605 if le or he:
00606 realEnd = (end+1)%2
00607 chanIndex = tower*8*2 + layer*2 + realEnd
00608 cRow = [tower,layer,realEnd,le,he,chanIndex,self.lci.ppcTimeInSec]
00609 cNt.addRow(cRow)
00610 return 0
00611
00612 def TKRdiag(self, tower, gtcc, diag):
00613 if 'tkr_trig' in self.lci.ntDict:
00614 cNt = self.lci.ntDict['tkr_trig']
00615 for gtrc in range(9):
00616 if (diag.datum()>>gtrc)&0x1:
00617 layer = self.__gtccLayerStart[gtcc]+4*gtrc
00618 end = self.__gtccEndMap[gtcc]
00619 chanIndex = tower*36*2+layer*2+end
00620 cRow = [tower,layer,end,chanIndex,self.lci.ppcTimeInSec]
00621 cNt.addRow(cRow)
00622 return 0
00623
00624 class GEMcontribution(object):
00625 def __init__(self, event, contribution,lci):
00626 self.lci = lci
00627 self.__event = event
00628 self.__contribution = contribution
00629
00630 def __getattr__(self, attr):
00631 """This method fakes up inheritance from an LDF.GEMcontribution.
00632 When a called method can not be found to belong to this class, this
00633 method is called. We use it to redirect the call to the 'base' class.
00634 """
00635 return getattr(self.__contribution, attr)
00636
00637 def fill(self, prefix = ""):
00638 tl = self.tileList()
00639 dtCalc = self.triggerTime()-self.lci.prevGemTime
00640 if (self.triggerTime()<self.lci.prevGemTime):
00641 # it rolled (happens every 1.7 seconds)
00642 dtCalc += 1<<25
00643 dtCalcInSec = dtCalc/20.e6
00644 gemTimeInSec = dtCalcInSec+self.lci.gemTimeInSec+dtCalcInSec
00645 dtRegInSec = self.deltaEventTime()/20.e6
00646 if 'gem_event' in self.lci.ntDict:
00647 livetimeInSec = self.liveTime()/20.e6
00648 prescale = self.prescaled()
00649 discarded = self.discarded()
00650 send = self.sent()
00651 numberTiles = 0
00652 for tileIndex in range(16):
00653 if (tl.XZM()>>tileIndex)&0x1: numberTiles+=1
00654 if (tl.XZP()>>tileIndex)&0x1: numberTiles+=1
00655 if (tl.YZM()>>tileIndex)&0x1: numberTiles+=1
00656 if (tl.YZP()>>tileIndex)&0x1: numberTiles+=1
00657 for tileIndex in range(25):
00658 if (tl.XY()>>tileIndex)&0x1: numberTiles+=1
00659 for tileIndex in range(8):
00660 if (tl.RBN()>>tileIndex)&0x1: numberTiles+=1
00661 for tileIndex in range(11):
00662 if (tl.NA()>>tileIndex)&0x1: numberTiles+=1
00663 cNt = self.lci.ntDict['gem_event']
00664 cRow = [dtRegInSec,dtCalcInSec,self.conditionSummary(),numberTiles,livetimeInSec,gemTimeInSec,prescale,discarded,send,self.lci.ppcTimeInSec]
00665 cNt.addRow(cRow)
00666 if 'gem_input' in self.lci.ntDict:
00667 cNt = self.lci.ntDict['gem_input']
00668 cRow = [self.cnoVector(),tl.XY(),tl.XZM(),tl.XZP(),tl.YZM(),tl.YZP(),tl.RBN(),tl.NA(),self.roiVector(),self.tkrVector(),self.calLEvector(),self.calHEvector(),self.lci.ppcTimeInSec]
00669 cNt.addRow(cRow)
00670 self.lci.prevGemTime = self.triggerTime()
00671 self.lci.gemTimeInSec = gemTimeInSec
00672
00673 class LATcontributionIterator(LDF.LDBI_LATcontributionIterator):
00674 def __init__(self, eei):
00675 LDF.LDBI_LATcontributionIterator.__init__(self, eei)
00676 self.__udfDict = {}
00677
00678 #def EBF(self, start, end): # Use the default
00679 # return status
00680
00681 def UDF(self, start, end):
00682 # the raw data is a string with comma separated key=value pairs
00683 udfString = str(start.rawData())
00684 # strip null characters
00685 import string
00686 udfString = string.strip(udfString,'\000')
00687
00688 # now split and see what you get
00689 udfList = string.split(udfString,',')
00690 for udfItem in udfList:
00691 udfSplitItem = string.split(udfItem,'=')
00692 if len(udfSplitItem) == 2:
00693 udfKey = string.strip(udfSplitItem[0])
00694 string.strip(udfSplitItem[1])
00695 udfValue = udfSplitItem[1]
00696 self.__udfDict[udfKey] = udfValue
00697 return 0
00698
00699 def getUdfDict(self):
00700 return self.__udfDict
00701
00702 def clearUdfDict(self):
00703 self.__udfDict.clear()
00704
00705 class EBFeventIterator(LDF.LDBI_EBFeventIterator):
00706 def __init__(self, lci):
00707 LDF.LDBI_EBFeventIterator.__init__(self, lci)
00708 self.__lci = lci
00709
00710 def process(self, evt):
00711 self.__lci.iterate(evt)
00712 return self.__lci.status()
00713
00714
00715 def hexdump( chars, sep, width ):
00716 while chars:
00717 line = chars[0:width]
00718 chars = chars[width:]
00719 line = line + '\000' * (width - len(line))
00720 print "%s%s%s" % ( sep.join( map( lambda c: "%02x" % ord(c), line )),sep, quotechars( line ))
00721
00722
00723 def quotechars( chars ):
00724 return ''.join( map( lambda c: ['.', c][c.isalnum()], chars ))
