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 __facility__ = "Trigger"
00011 __abstract__ = "GLAST Trigger consumer"
00012 __author__ = "Martin Kocian"
00013 __date__ = "5/13/2005"
00014 __version__ = "$Revision: 2.7 $"
00015 __credits__ = "SLAC"
00016 import LATTE.copyright_SLAC
00017 import LDF
00018 import LATTE.consumer.standardLDF as standardLDF
00019 from LATTE.tools.DataDistributor import DataDistributorClient
00020 import struct
00021 import time
00022 import sys
00023 import getopt
00024 import array
00025 import logging as myLog
00026
00027 class trgLATcomponentIterator(LDF.LATcomponentIterator):
00028 def __init__(self):
00029 LDF.LATcomponentIterator.__init__(self)
00030 self.condsummary=None
00031 self.deltatime=None
00032 self.deltawtime=None
00033 self.condtime=None
00034 self.tkrvector=0
00035 self.roivector=0
00036 self.cnovector=0
00037 self.callowvector=0
00038 self.calhighvector=0
00039 self.triggertime=0
00040 self.ppstimebase=0
00041 self.ppsseconds=0
00042
00043 def GEMcomponent(self,event,gemContribution):
00044 self.condsummary=gemContribution.conditionSummary()&0xff
00045 #print "condsummary %x" % self.condsummary
00046 self.deltatime=gemContribution.deltaEventTime()
00047 #print "delta event time %d"% self.deltatime
00048 self.deltawtime=gemContribution.deltaWindowOpenTime()
00049 self.condtime=[31,31,31,31,31,31]
00050 self.condtime[0]=gemContribution.condArrTime().roi()
00051 self.condtime[1]=gemContribution.condArrTime().tkr()
00052 self.condtime[2]=gemContribution.condArrTime().calLE()
00053 self.condtime[3]=gemContribution.condArrTime().calHE()
00054 self.condtime[4]=gemContribution.condArrTime().cno()
00055 self.condtime[5]=gemContribution.condArrTime().external()
00056 self.roivector=gemContribution.roiVector()
00057 self.cnovector=gemContribution.cnoVector()
00058 self.tkrvector=gemContribution.tkrVector()
00059 self.callowvector=gemContribution.calLEvector()
00060 self.calhighvector=gemContribution.calHEvector()
00061 self.triggertime=gemContribution.triggerTime()
00062 self.ppstimebase=gemContribution.onePPStime().timebase()
00063 self.ppsseconds=gemContribution.onePPStime().seconds()
00064 return 0
00065
00066 class trgConsumer:
00067 def __init__(self,server,infile):
00068 self.lci = trgLATcomponentIterator()
00069 self.eei = standardLDF.EBFeventIterator(self.lci)
00070 self.lcti = standardLDF.LATcontributionIterator(self.eei)
00071 self.ldbi = LDF.LATdataBufferIterator(self.lcti)
00072 self.__ds = None
00073 self.__file = None
00074 self.__debug = 0
00075 self.eventData = None
00076 self.__inFileName = infile
00077 self.__nEvents = 0
00078 self.__server = server
00079 self.__runId = ''
00080 self.startRun = False
00081 self.runhasstarted = False
00082 self.readlut = True
00083 self.endRun = False
00084 self.exit = False
00085 self.winwidth=0
00086
00087 self.conf=1
00088 self.resethistos=False
00089 self.solicited=0
00090 self.tkr=0
00091 self.callow=0
00092 self.calhigh=0
00093 self.cno=0
00094 self.roi=0
00095 self.periodic=0
00096 self.ext=0
00097 self.tkrvector=[]
00098 self.roivector=[]
00099 self.cnovector=[]
00100 self.callowvector=[]
00101 self.calhighvector=[]
00102 self.orvector=[]
00103 for i in range(16):
00104 self.tkrvector.append(0)
00105 self.roivector.append(0)
00106 self.cnovector.append(0)
00107 self.callowvector.append(0)
00108 self.calhighvector.append(0)
00109 self.orvector.append(0)
00110 self.deltatime=[]
00111 self.deltawtime=[]
00112 self.events=0
00113 self.ref=5
00114 self.roitime=[]
00115 self.tkrtime=[]
00116 self.callowtime=[]
00117 self.calhightime=[]
00118 self.cnotime=[]
00119 self.timematrix=None
00120 self.timehisto=None
00121 self.exttime=[]
00122 self.condsum=[]
00123 self.timestamp=0
00124
00125 def checkUDF(self):
00126 udfDict = self.lcti.getUdfDict()
00127 self.startRun = False
00128 if 'startRun' in udfDict:
00129 self.setRunId(udfDict['startRun'])
00130 self.startRun = True
00131 self.endRun = False
00132 if 'endRun' in udfDict:
00133 self.endRun = True
00134 self.lcti.clearUdfDict()
00135
00136 def getRunId(self):
00137 return self.__runId
00138 def setRunId(self,runId):
00139 self.__runId = runId
00140 def resetWindowData(self):
00141 self.deltatime=[]
00142 self.deltawtime=[]
00143 self.roitime=[]
00144 self.tkrtime=[]
00145 self.callowtime=[]
00146 self.calhightime=[]
00147 self.cnotime=[]
00148 self.exttime=[]
00149 self.condsum=[]
00150 def getNextEvent(self):
00151 """get Next Event into data buffer
00152 """
00153 if self.__file is not None:
00154 evtPtr = self.__file.tell()
00155 # get datagram
00156 self.eventData = self.__file.read(8)
00157 # check for file end
00158 if len(self.eventData) < 8:
00159 myLog.info("Consumer.getNextEvent: End of File")
00160 return 0
00161 # unpack pair of big-endian 4 byte words
00162 # this is presumably broken for Sun hardware
00163 (identity, length) = struct.unpack('!LL', self.eventData)
00164 self.eventData += self.__file.read(length - 8)
00165 if self.__debug:
00166 myLog.info("got data %d length from file" % (length))
00167 return length
00168 if self.__ds is not None:
00169 self.eventData, sender = self.__ds.receive()
00170 if self.eventData is None:
00171 #print "No data from server"
00172 return 1
00173 if self.__debug:
00174 print("got data %d length from file" % len(self.eventData))
00175 return 1
00176 myLog.warn("Consumer.getNextEvent: No data source")
00177 return 0
00178 def serverOpen(self, server="1"):
00179 """ Connect to network server
00180 """
00181 myLog.info("Consumer.serverOpen: Connecting to data server %s"%(server))
00182 # Close previous data sources
00183 if self.__file is not None:
00184 self.__fileClose()
00185 if self.__ds is not None:
00186 self.serverClose()
00187 dsName = 'LAT_EBFdata'
00188 self.__ds = DataDistributorClient(dsName)
00189 if self.__ds is not None:
00190 self.__ds.connect(server)
00191 #self.__ds.start()
00192 else:
00193 myLog.warn("Consumer.serverOpen: Unable to connect to Data Distribution server %s"%(server))
00194 sys.exit(2)
00195
00196 def serverClose(self):
00197 """ Close network server
00198 """
00199 if self.__ds is not None:
00200 self.__ds.disconnect()
00201 self.__ds = None
00202 def fileOpen(self,fn):
00203 """ Load input data from a file
00204 """
00205 # Close previous data sources
00206 if self.__ds is not None:
00207 self.serverClose()
00208 if self.__file is not None:
00209 self.__fileClose()
00210 try:
00211 self.__file = open(fn, 'rb')
00212 except:
00213 myLog.warn("Consumer.fileOpen: Fatal: failed to open file %s"%(fn))
00214 sys.exit(2)
00215 myLog.info("Consumer.fileOpen: opening file %s"%(fn))
00216
00217 def fileClose(self):
00218 """ Close input data file
00219 """
00220 if self.__file is not None:
00221 self.__file.close()
00222 self.__file = None
00223 return
00224
00225 def dataSize(self):
00226 """Return current event data size
00227 """
00228 if self.eventData is not None:
00229 return len(self.eventData)
00230 else:
00231 return 0
00232
00233 def exitConsumer(self):
00234 self.exit=True
00235 self.__ds.returnNone()
00236
00237 def parseEvent(self):
00238 self.ldbi.iterate(self.eventData, len(self.eventData))
00239 self.checkUDF()
00240 if self.runhasstarted==True:
00241 self.readlut=True
00242 self.runhasstarted=False
00243 if self.startRun==True:
00244 self.resethistos=True
00245 self.resetWindowData()
00246 self.timematrix=None
00247 self.runhasstarted=True
00248 if self.lci.condsummary!=None and self.lci.deltatime!=None and self.lci.deltawtime!=None:
00249 self.events+=1
00250 self.solicited+=bool(self.lci.condsummary&0x40)
00251 self.tkr+=bool(self.lci.condsummary&0x2)
00252 self.callow+=bool(self.lci.condsummary&0x4)
00253 self.calhigh+=bool(self.lci.condsummary&0x8)
00254 self.cno+=bool(self.lci.condsummary&0x10)
00255 self.roi+=bool(self.lci.condsummary&0x1)
00256 self.ext+=bool(self.lci.condsummary&0x80)
00257 self.periodic+=bool(self.lci.condsummary&0x20)
00258 self.deltatime.append(self.lci.deltatime)
00259 self.deltawtime.append(self.lci.deltawtime)
00260 self.condsum.append(self.lci.condsummary)
00261 reftime=31
00262 reftime=self.lci.condtime[self.ref]
00263 if reftime!=31:
00264 if self.lci.condtime[0]!=31 and self.ref!=0: self.timehisto.fill("ROI",self.lci.condtime[0]-reftime)
00265 if self.lci.condtime[1]!=31 and self.ref!=1: self.timehisto.fill("TKR",self.lci.condtime[1]-reftime)
00266 if self.lci.condtime[2]!=31 and self.ref!=2: self.timehisto.fill("CALlow",self.lci.condtime[2]-reftime)
00267 if self.lci.condtime[3]!=31 and self.ref!=3: self.timehisto.fill("CALhigh",self.lci.condtime[3]-reftime)
00268 if self.lci.condtime[4]!=31 and self.ref!=4: self.timehisto.fill("CNO",self.lci.condtime[4]-reftime)
00269 if self.lci.condtime[5]!=31 and self.ref!=5: self.timehisto.fill("EXT",self.lci.condtime[5]-reftime)
00270 if self.timematrix==None:
00271 self.timematrix=[]
00272 for i in range(6):
00273 self.timematrix.append([])
00274 for j in range(6):
00275 self.timematrix[i].append([])
00276 for k in range(2*self.winwidth+1):
00277 self.timematrix[i][j].append(0)
00278 for i in range(6):
00279 for j in range(i+1,6):
00280 if self.lci.condtime[i]!=31 and self.lci.condtime[j]!=31:
00281 self.timematrix[i][j][self.winwidth+self.lci.condtime[j]-self.lci.condtime[i]]+=1
00282 orv=self.lci.callowvector|self.lci.calhighvector
00283
00284 if self.conf:
00285 orv|=self.lci.tkrvector
00286 else:
00287 orv|=(self.lci.tkrvector&~self.lci.roivector)
00288 for i in range (16):
00289 self.tkrvector[i]+=bool(self.lci.tkrvector&(1<<i))
00290 self.roivector[i]+=bool(self.lci.roivector&(1<<i))
00291 self.cnovector[i]+=bool(self.lci.cnovector&(1<<i))
00292 self.callowvector[i]+=bool(self.lci.callowvector&(1<<i))
00293 self.calhighvector[i]+=bool(self.lci.calhighvector&(1<<i))
00294 self.orvector[i]+=bool(orv&(1<<i))
00295 if self.lci.triggertime>self.lci.ppstimebase:
00296 self.timestamp=self.lci.ppsseconds+50.e-9*(self.lci.triggertime-self.lci.ppstimebase)
00297 else:
00298 self.timestamp=self.lci.ppsseconds+50.e-9*(self.lci.triggertime+33554432-self.lci.ppstimebase)
00299 def loop(self):
00300 if self.__inFileName is not None:
00301 self.fileOpen(self.__inFileName)
00302 else:
00303 self.serverOpen(self.__server)
00304 eventCount=0
00305 archivedEventCount=0
00306 sayWaiting = 0
00307 timeLastEvent = 0
00308 # self.exit is set by another thread (trgDisplayImpl)
00309 while (not self.exit):
00310 self.getNextEvent()
00311 if self.eventData is not None and self.dataSize()>0:
00312 timeLastEvent = time.time()
00313 eventCount+=1
00314 self.parseEvent()
00315 if sayWaiting==1:
00316 sayWaiting=0
00317 #print "resumed acquisition... (eventCount is ",eventCount,")"
00318 else:
00319 deltaTime = time.time() - timeLastEvent
00320 if sayWaiting==0 and deltaTime>1:
00321 sayWaiting=1
00322 #print "Waiting for data..."
00323
00324 myLog.info("Consumer: Read in %d events" % (eventCount))
00325 self.serverClose()
00326 self.fileClose()
00327 def reloadData(self):
00328 if self.timematrix==None:return
00329 for j in range(6):
00330 if j>self.ref:
00331 for k in range (2*self.winwidth+1):
00332 if j==0:self.timehisto.setBinContent("ROI",k,self.timematrix[self.ref][j][k])
00333 if j==1:self.timehisto.setBinContent("TKR",k,self.timematrix[self.ref][j][k])
00334 if j==2:self.timehisto.setBinContent("CALlow",k,self.timematrix[self.ref][j][k])
00335 if j==3:self.timehisto.setBinContent("CALhigh",k,self.timematrix[self.ref][j][k])
00336 if j==4:self.timehisto.setBinContent("CNO",k,self.timematrix[self.ref][j][k])
00337 if j==5:self.timehisto.setBinContent("EXT",k,self.timematrix[self.ref][j][k])
00338 elif j<self.ref:
00339 for k in range(2*self.winwidth+1):
00340 if j==0:self.timehisto.setBinContent("ROI",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00341 if j==1:self.timehisto.setBinContent("TKR",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00342 if j==2:self.timehisto.setBinContent("CALlow",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00343 if j==3:self.timehisto.setBinContent("CALhigh",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00344 if j==4:self.timehisto.setBinContent("CNO",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00345 if j==5:self.timehisto.setBinContent("EXT",2*self.winwidth-k,self.timematrix[j][self.ref][k]),
00346 if __name__ == '__main__':
00347 cons = trgConsumer(sys.argv[1:])
00348 cons.loop()
00349
