##// END OF EJS Templates
schain
RSS
Bug fixed in ProcessingHeader: code is never stored
Miguel Valdez -
r778:439a8eb4152d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,757 +1,757
1 '''
1 '''
2
2
3 $Author: murco $
3 $Author: murco $
4 $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
4 $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
5 '''
5 '''
6 import numpy
6 import numpy
7 import copy
7 import copy
8 import datetime
8 import datetime
9
9
10 SPEED_OF_LIGHT = 299792458
10 SPEED_OF_LIGHT = 299792458
11 SPEED_OF_LIGHT = 3e8
11 SPEED_OF_LIGHT = 3e8
12
12
13 BASIC_STRUCTURE = numpy.dtype([
13 BASIC_STRUCTURE = numpy.dtype([
14 ('nSize','<u4'),
14 ('nSize','<u4'),
15 ('nVersion','<u2'),
15 ('nVersion','<u2'),
16 ('nDataBlockId','<u4'),
16 ('nDataBlockId','<u4'),
17 ('nUtime','<u4'),
17 ('nUtime','<u4'),
18 ('nMilsec','<u2'),
18 ('nMilsec','<u2'),
19 ('nTimezone','<i2'),
19 ('nTimezone','<i2'),
20 ('nDstflag','<i2'),
20 ('nDstflag','<i2'),
21 ('nErrorCount','<u4')
21 ('nErrorCount','<u4')
22 ])
22 ])
23
23
24 SYSTEM_STRUCTURE = numpy.dtype([
24 SYSTEM_STRUCTURE = numpy.dtype([
25 ('nSize','<u4'),
25 ('nSize','<u4'),
26 ('nNumSamples','<u4'),
26 ('nNumSamples','<u4'),
27 ('nNumProfiles','<u4'),
27 ('nNumProfiles','<u4'),
28 ('nNumChannels','<u4'),
28 ('nNumChannels','<u4'),
29 ('nADCResolution','<u4'),
29 ('nADCResolution','<u4'),
30 ('nPCDIOBusWidth','<u4'),
30 ('nPCDIOBusWidth','<u4'),
31 ])
31 ])
32
32
33 RADAR_STRUCTURE = numpy.dtype([
33 RADAR_STRUCTURE = numpy.dtype([
34 ('nSize','<u4'),
34 ('nSize','<u4'),
35 ('nExpType','<u4'),
35 ('nExpType','<u4'),
36 ('nNTx','<u4'),
36 ('nNTx','<u4'),
37 ('fIpp','<f4'),
37 ('fIpp','<f4'),
38 ('fTxA','<f4'),
38 ('fTxA','<f4'),
39 ('fTxB','<f4'),
39 ('fTxB','<f4'),
40 ('nNumWindows','<u4'),
40 ('nNumWindows','<u4'),
41 ('nNumTaus','<u4'),
41 ('nNumTaus','<u4'),
42 ('nCodeType','<u4'),
42 ('nCodeType','<u4'),
43 ('nLine6Function','<u4'),
43 ('nLine6Function','<u4'),
44 ('nLine5Function','<u4'),
44 ('nLine5Function','<u4'),
45 ('fClock','<f4'),
45 ('fClock','<f4'),
46 ('nPrePulseBefore','<u4'),
46 ('nPrePulseBefore','<u4'),
47 ('nPrePulseAfter','<u4'),
47 ('nPrePulseAfter','<u4'),
48 ('sRangeIPP','<a20'),
48 ('sRangeIPP','<a20'),
49 ('sRangeTxA','<a20'),
49 ('sRangeTxA','<a20'),
50 ('sRangeTxB','<a20'),
50 ('sRangeTxB','<a20'),
51 ])
51 ])
52
52
53 SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
53 SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
54
54
55
55
56 PROCESSING_STRUCTURE = numpy.dtype([
56 PROCESSING_STRUCTURE = numpy.dtype([
57 ('nSize','<u4'),
57 ('nSize','<u4'),
58 ('nDataType','<u4'),
58 ('nDataType','<u4'),
59 ('nSizeOfDataBlock','<u4'),
59 ('nSizeOfDataBlock','<u4'),
60 ('nProfilesperBlock','<u4'),
60 ('nProfilesperBlock','<u4'),
61 ('nDataBlocksperFile','<u4'),
61 ('nDataBlocksperFile','<u4'),
62 ('nNumWindows','<u4'),
62 ('nNumWindows','<u4'),
63 ('nProcessFlags','<u4'),
63 ('nProcessFlags','<u4'),
64 ('nCoherentIntegrations','<u4'),
64 ('nCoherentIntegrations','<u4'),
65 ('nIncoherentIntegrations','<u4'),
65 ('nIncoherentIntegrations','<u4'),
66 ('nTotalSpectra','<u4')
66 ('nTotalSpectra','<u4')
67 ])
67 ])
68
68
69 class Header(object):
69 class Header(object):
70
70
71 def __init__(self):
71 def __init__(self):
72 raise NotImplementedError
72 raise NotImplementedError
73
73
74 def copy(self):
74 def copy(self):
75 return copy.deepcopy(self)
75 return copy.deepcopy(self)
76
76
77 def read(self):
77 def read(self):
78
78
79 raise NotImplementedError
79 raise NotImplementedError
80
80
81 def write(self):
81 def write(self):
82
82
83 raise NotImplementedError
83 raise NotImplementedError
84
84
85 def printInfo(self):
85 def printInfo(self):
86
86
87 message = "#"*50 + "\n"
87 message = "#"*50 + "\n"
88 message += self.__class__.__name__.upper() + "\n"
88 message += self.__class__.__name__.upper() + "\n"
89 message += "#"*50 + "\n"
89 message += "#"*50 + "\n"
90
90
91 keyList = self.__dict__.keys()
91 keyList = self.__dict__.keys()
92 keyList.sort()
92 keyList.sort()
93
93
94 for key in keyList:
94 for key in keyList:
95 message += "%s = %s" %(key, self.__dict__[key]) + "\n"
95 message += "%s = %s" %(key, self.__dict__[key]) + "\n"
96
96
97 if "size" not in keyList:
97 if "size" not in keyList:
98 attr = getattr(self, "size")
98 attr = getattr(self, "size")
99
99
100 if attr:
100 if attr:
101 message += "%s = %s" %("size", attr) + "\n"
101 message += "%s = %s" %("size", attr) + "\n"
102
102
103 print message
103 print message
104
104
105 class BasicHeader(Header):
105 class BasicHeader(Header):
106
106
107 size = None
107 size = None
108 version = None
108 version = None
109 dataBlock = None
109 dataBlock = None
110 utc = None
110 utc = None
111 ltc = None
111 ltc = None
112 miliSecond = None
112 miliSecond = None
113 timeZone = None
113 timeZone = None
114 dstFlag = None
114 dstFlag = None
115 errorCount = None
115 errorCount = None
116 datatime = None
116 datatime = None
117
117
118 __LOCALTIME = None
118 __LOCALTIME = None
119
119
120 def __init__(self, useLocalTime=True):
120 def __init__(self, useLocalTime=True):
121
121
122 self.size = 24
122 self.size = 24
123 self.version = 0
123 self.version = 0
124 self.dataBlock = 0
124 self.dataBlock = 0
125 self.utc = 0
125 self.utc = 0
126 self.miliSecond = 0
126 self.miliSecond = 0
127 self.timeZone = 0
127 self.timeZone = 0
128 self.dstFlag = 0
128 self.dstFlag = 0
129 self.errorCount = 0
129 self.errorCount = 0
130
130
131 self.useLocalTime = useLocalTime
131 self.useLocalTime = useLocalTime
132
132
133 def read(self, fp):
133 def read(self, fp):
134
134
135 try:
135 try:
136 header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
136 header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
137
137
138 except Exception, e:
138 except Exception, e:
139 print "BasicHeader: "
139 print "BasicHeader: "
140 print e
140 print e
141 return 0
141 return 0
142
142
143 self.size = int(header['nSize'][0])
143 self.size = int(header['nSize'][0])
144 self.version = int(header['nVersion'][0])
144 self.version = int(header['nVersion'][0])
145 self.dataBlock = int(header['nDataBlockId'][0])
145 self.dataBlock = int(header['nDataBlockId'][0])
146 self.utc = int(header['nUtime'][0])
146 self.utc = int(header['nUtime'][0])
147 self.miliSecond = int(header['nMilsec'][0])
147 self.miliSecond = int(header['nMilsec'][0])
148 self.timeZone = int(header['nTimezone'][0])
148 self.timeZone = int(header['nTimezone'][0])
149 self.dstFlag = int(header['nDstflag'][0])
149 self.dstFlag = int(header['nDstflag'][0])
150 self.errorCount = int(header['nErrorCount'][0])
150 self.errorCount = int(header['nErrorCount'][0])
151
151
152 return 1
152 return 1
153
153
154 def write(self, fp):
154 def write(self, fp):
155
155
156 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
156 headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
157 header = numpy.array(headerTuple, BASIC_STRUCTURE)
157 header = numpy.array(headerTuple, BASIC_STRUCTURE)
158 header.tofile(fp)
158 header.tofile(fp)
159
159
160 return 1
160 return 1
161
161
162 def get_ltc(self):
162 def get_ltc(self):
163
163
164 return self.utc - self.timeZone*60
164 return self.utc - self.timeZone*60
165
165
166 def set_ltc(self, value):
166 def set_ltc(self, value):
167
167
168 self.utc = value + self.timeZone*60
168 self.utc = value + self.timeZone*60
169
169
170 def get_datatime(self):
170 def get_datatime(self):
171
171
172 return datetime.datetime.utcfromtimestamp(self.ltc)
172 return datetime.datetime.utcfromtimestamp(self.ltc)
173
173
174 ltc = property(get_ltc, set_ltc)
174 ltc = property(get_ltc, set_ltc)
175 datatime = property(get_datatime)
175 datatime = property(get_datatime)
176
176
177 class SystemHeader(Header):
177 class SystemHeader(Header):
178
178
179 size = None
179 size = None
180 nSamples = None
180 nSamples = None
181 nProfiles = None
181 nProfiles = None
182 nChannels = None
182 nChannels = None
183 adcResolution = None
183 adcResolution = None
184 pciDioBusWidth = None
184 pciDioBusWidth = None
185
185
186 def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWith=0):
186 def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWith=0):
187
187
188 self.size = 24
188 self.size = 24
189 self.nSamples = nSamples
189 self.nSamples = nSamples
190 self.nProfiles = nProfiles
190 self.nProfiles = nProfiles
191 self.nChannels = nChannels
191 self.nChannels = nChannels
192 self.adcResolution = adcResolution
192 self.adcResolution = adcResolution
193 self.pciDioBusWidth = pciDioBusWith
193 self.pciDioBusWidth = pciDioBusWith
194
194
195 def read(self, fp):
195 def read(self, fp):
196
196
197 startFp = fp.tell()
197 startFp = fp.tell()
198
198
199 try:
199 try:
200 header = numpy.fromfile(fp,SYSTEM_STRUCTURE,1)
200 header = numpy.fromfile(fp,SYSTEM_STRUCTURE,1)
201 except Exception, e:
201 except Exception, e:
202 print "System Header: " + e
202 print "System Header: " + e
203 return 0
203 return 0
204
204
205 self.size = header['nSize'][0]
205 self.size = header['nSize'][0]
206 self.nSamples = header['nNumSamples'][0]
206 self.nSamples = header['nNumSamples'][0]
207 self.nProfiles = header['nNumProfiles'][0]
207 self.nProfiles = header['nNumProfiles'][0]
208 self.nChannels = header['nNumChannels'][0]
208 self.nChannels = header['nNumChannels'][0]
209 self.adcResolution = header['nADCResolution'][0]
209 self.adcResolution = header['nADCResolution'][0]
210 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
210 self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
211
211
212 endFp = self.size + startFp
212 endFp = self.size + startFp
213
213
214 if fp.tell() > endFp:
214 if fp.tell() > endFp:
215 sys.stderr.write("Warning: System header size is lower than it has to be")
215 sys.stderr.write("Warning: System header size is lower than it has to be")
216 return 0
216 return 0
217
217
218 if fp.tell() < endFp:
218 if fp.tell() < endFp:
219 sys.stderr.write("Warning: System header size is greater than it is considered")
219 sys.stderr.write("Warning: System header size is greater than it is considered")
220
220
221 return 1
221 return 1
222
222
223 def write(self, fp):
223 def write(self, fp):
224
224
225 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
225 headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
226 header = numpy.array(headerTuple,SYSTEM_STRUCTURE)
226 header = numpy.array(headerTuple,SYSTEM_STRUCTURE)
227 header.tofile(fp)
227 header.tofile(fp)
228
228
229 return 1
229 return 1
230
230
231 class RadarControllerHeader(Header):
231 class RadarControllerHeader(Header):
232
232
233 expType = None
233 expType = None
234 nTx = None
234 nTx = None
235 ipp = None
235 ipp = None
236 txA = None
236 txA = None
237 txB = None
237 txB = None
238 nWindows = None
238 nWindows = None
239 numTaus = None
239 numTaus = None
240 codeType = None
240 codeType = None
241 line6Function = None
241 line6Function = None
242 line5Function = None
242 line5Function = None
243 fClock = None
243 fClock = None
244 prePulseBefore = None
244 prePulseBefore = None
245 prePulserAfter = None
245 prePulserAfter = None
246 rangeIpp = None
246 rangeIpp = None
247 rangeTxA = None
247 rangeTxA = None
248 rangeTxB = None
248 rangeTxB = None
249
249
250 __size = None
250 __size = None
251
251
252 def __init__(self, expType=2, nTx=1,
252 def __init__(self, expType=2, nTx=1,
253 ippKm=None, txA=0, txB=0,
253 ippKm=None, txA=0, txB=0,
254 nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
254 nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
255 numTaus=0, line6Function=0, line5Function=0, fClock=None,
255 numTaus=0, line6Function=0, line5Function=0, fClock=None,
256 prePulseBefore=0, prePulseAfter=0,
256 prePulseBefore=0, prePulseAfter=0,
257 codeType=0, nCode=0, nBaud=0, code=None,
257 codeType=0, nCode=0, nBaud=0, code=None,
258 flip1=0, flip2=0):
258 flip1=0, flip2=0):
259
259
260 # self.size = 116
260 # self.size = 116
261 self.expType = expType
261 self.expType = expType
262 self.nTx = nTx
262 self.nTx = nTx
263 self.ipp = ippKm
263 self.ipp = ippKm
264 self.txA = txA
264 self.txA = txA
265 self.txB = txB
265 self.txB = txB
266 self.rangeIpp = ippKm
266 self.rangeIpp = ippKm
267 self.rangeTxA = txA
267 self.rangeTxA = txA
268 self.rangeTxB = txB
268 self.rangeTxB = txB
269
269
270 self.nWindows = nWindows
270 self.nWindows = nWindows
271 self.numTaus = numTaus
271 self.numTaus = numTaus
272 self.codeType = codeType
272 self.codeType = codeType
273 self.line6Function = line6Function
273 self.line6Function = line6Function
274 self.line5Function = line5Function
274 self.line5Function = line5Function
275 self.fClock = fClock
275 self.fClock = fClock
276 self.prePulseBefore = prePulseBefore
276 self.prePulseBefore = prePulseBefore
277 self.prePulserAfter = prePulseAfter
277 self.prePulserAfter = prePulseAfter
278
278
279 self.nHeights = nHeights
279 self.nHeights = nHeights
280 self.firstHeight = firstHeight
280 self.firstHeight = firstHeight
281 self.deltaHeight = deltaHeight
281 self.deltaHeight = deltaHeight
282 self.samplesWin = nHeights
282 self.samplesWin = nHeights
283
283
284 self.nCode = nCode
284 self.nCode = nCode
285 self.nBaud = nBaud
285 self.nBaud = nBaud
286 self.code = code
286 self.code = code
287 self.flip1 = flip1
287 self.flip1 = flip1
288 self.flip2 = flip2
288 self.flip2 = flip2
289
289
290 self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
290 self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
291 # self.dynamic = numpy.array([],numpy.dtype('byte'))
291 # self.dynamic = numpy.array([],numpy.dtype('byte'))
292
292
293 if self.fClock is None and self.deltaHeight is not None:
293 if self.fClock is None and self.deltaHeight is not None:
294 self.fClock = 0.15/(deltaHeight*1e-6) #0.15Km / (height * 1u)
294 self.fClock = 0.15/(deltaHeight*1e-6) #0.15Km / (height * 1u)
295
295
296 def read(self, fp):
296 def read(self, fp):
297
297
298
298
299 startFp = fp.tell()
299 startFp = fp.tell()
300 try:
300 try:
301 header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
301 header = numpy.fromfile(fp,RADAR_STRUCTURE,1)
302 except Exception, e:
302 except Exception, e:
303 print "RadarControllerHeader: " + e
303 print "RadarControllerHeader: " + e
304 return 0
304 return 0
305
305
306 size = int(header['nSize'][0])
306 size = int(header['nSize'][0])
307 self.expType = int(header['nExpType'][0])
307 self.expType = int(header['nExpType'][0])
308 self.nTx = int(header['nNTx'][0])
308 self.nTx = int(header['nNTx'][0])
309 self.ipp = float(header['fIpp'][0])
309 self.ipp = float(header['fIpp'][0])
310 self.txA = float(header['fTxA'][0])
310 self.txA = float(header['fTxA'][0])
311 self.txB = float(header['fTxB'][0])
311 self.txB = float(header['fTxB'][0])
312 self.nWindows = int(header['nNumWindows'][0])
312 self.nWindows = int(header['nNumWindows'][0])
313 self.numTaus = int(header['nNumTaus'][0])
313 self.numTaus = int(header['nNumTaus'][0])
314 self.codeType = int(header['nCodeType'][0])
314 self.codeType = int(header['nCodeType'][0])
315 self.line6Function = int(header['nLine6Function'][0])
315 self.line6Function = int(header['nLine6Function'][0])
316 self.line5Function = int(header['nLine5Function'][0])
316 self.line5Function = int(header['nLine5Function'][0])
317 self.fClock = float(header['fClock'][0])
317 self.fClock = float(header['fClock'][0])
318 self.prePulseBefore = int(header['nPrePulseBefore'][0])
318 self.prePulseBefore = int(header['nPrePulseBefore'][0])
319 self.prePulserAfter = int(header['nPrePulseAfter'][0])
319 self.prePulserAfter = int(header['nPrePulseAfter'][0])
320 self.rangeIpp = header['sRangeIPP'][0]
320 self.rangeIpp = header['sRangeIPP'][0]
321 self.rangeTxA = header['sRangeTxA'][0]
321 self.rangeTxA = header['sRangeTxA'][0]
322 self.rangeTxB = header['sRangeTxB'][0]
322 self.rangeTxB = header['sRangeTxB'][0]
323
323
324 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
324 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
325
325
326 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
326 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
327 self.firstHeight = samplingWindow['h0']
327 self.firstHeight = samplingWindow['h0']
328 self.deltaHeight = samplingWindow['dh']
328 self.deltaHeight = samplingWindow['dh']
329 self.samplesWin = samplingWindow['nsa']
329 self.samplesWin = samplingWindow['nsa']
330
330
331 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
331 self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
332
332
333 self.code_size = 0
333 self.code_size = 0
334 if self.codeType != 0:
334 if self.codeType != 0:
335 self.nCode = int(numpy.fromfile(fp,'<u4',1))
335 self.nCode = int(numpy.fromfile(fp,'<u4',1))
336 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
336 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
337
337
338 code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
338 code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
339 for ic in range(self.nCode):
339 for ic in range(self.nCode):
340 temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
340 temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
341 for ib in range(self.nBaud-1,-1,-1):
341 for ib in range(self.nBaud-1,-1,-1):
342 code[ic,ib] = temp[ib/32]%2
342 code[ic,ib] = temp[ib/32]%2
343 temp[ib/32] = temp[ib/32]/2
343 temp[ib/32] = temp[ib/32]/2
344
344
345 self.code = 2.0*code - 1.0
345 self.code = 2.0*code - 1.0
346 self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
346 self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
347
347
348 # if self.line5Function == RCfunction.FLIP:
348 # if self.line5Function == RCfunction.FLIP:
349 # self.flip1 = numpy.fromfile(fp,'<u4',1)
349 # self.flip1 = numpy.fromfile(fp,'<u4',1)
350 #
350 #
351 # if self.line6Function == RCfunction.FLIP:
351 # if self.line6Function == RCfunction.FLIP:
352 # self.flip2 = numpy.fromfile(fp,'<u4',1)
352 # self.flip2 = numpy.fromfile(fp,'<u4',1)
353
353
354 endFp = size + startFp
354 endFp = size + startFp
355
355
356 if fp.tell() != endFp:
356 if fp.tell() != endFp:
357 # fp.seek(endFp)
357 # fp.seek(endFp)
358 print "Radar Controller Header is not consistent read[%d] != header[%d]" %(fp.tell()-startFp,endFp)
358 print "Radar Controller Header is not consistent read[%d] != header[%d]" %(fp.tell()-startFp,endFp)
359 # return 0
359 # return 0
360
360
361 if fp.tell() > endFp:
361 if fp.tell() > endFp:
362 sys.stderr.write("Warning: Radar Controller header size is lower than it has to be")
362 sys.stderr.write("Warning: Radar Controller header size is lower than it has to be")
363 # return 0
363 # return 0
364
364
365 if fp.tell() < endFp:
365 if fp.tell() < endFp:
366 sys.stderr.write("Warning: Radar Controller header size is greater than it is considered")
366 sys.stderr.write("Warning: Radar Controller header size is greater than it is considered")
367
367
368
368
369 return 1
369 return 1
370
370
371 def write(self, fp):
371 def write(self, fp):
372
372
373 headerTuple = (self.size,
373 headerTuple = (self.size,
374 self.expType,
374 self.expType,
375 self.nTx,
375 self.nTx,
376 self.ipp,
376 self.ipp,
377 self.txA,
377 self.txA,
378 self.txB,
378 self.txB,
379 self.nWindows,
379 self.nWindows,
380 self.numTaus,
380 self.numTaus,
381 self.codeType,
381 self.codeType,
382 self.line6Function,
382 self.line6Function,
383 self.line5Function,
383 self.line5Function,
384 self.fClock,
384 self.fClock,
385 self.prePulseBefore,
385 self.prePulseBefore,
386 self.prePulserAfter,
386 self.prePulserAfter,
387 self.rangeIpp,
387 self.rangeIpp,
388 self.rangeTxA,
388 self.rangeTxA,
389 self.rangeTxB)
389 self.rangeTxB)
390
390
391 header = numpy.array(headerTuple,RADAR_STRUCTURE)
391 header = numpy.array(headerTuple,RADAR_STRUCTURE)
392 header.tofile(fp)
392 header.tofile(fp)
393
393
394 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
394 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
395 samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
395 samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
396 samplingWindow.tofile(fp)
396 samplingWindow.tofile(fp)
397
397
398 if self.numTaus > 0:
398 if self.numTaus > 0:
399 self.Taus.tofile(fp)
399 self.Taus.tofile(fp)
400
400
401 if self.codeType !=0:
401 if self.codeType !=0:
402 nCode = numpy.array(self.nCode, '<u4')
402 nCode = numpy.array(self.nCode, '<u4')
403 nCode.tofile(fp)
403 nCode.tofile(fp)
404 nBaud = numpy.array(self.nBaud, '<u4')
404 nBaud = numpy.array(self.nBaud, '<u4')
405 nBaud.tofile(fp)
405 nBaud.tofile(fp)
406 code1 = (self.code + 1.0)/2.
406 code1 = (self.code + 1.0)/2.
407
407
408 for ic in range(self.nCode):
408 for ic in range(self.nCode):
409 tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
409 tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
410 start = 0
410 start = 0
411 end = 32
411 end = 32
412 for i in range(len(tempx)):
412 for i in range(len(tempx)):
413 code_selected = code1[ic,start:end]
413 code_selected = code1[ic,start:end]
414 for j in range(len(code_selected)-1,-1,-1):
414 for j in range(len(code_selected)-1,-1,-1):
415 if code_selected[j] == 1:
415 if code_selected[j] == 1:
416 tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
416 tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
417 start = start + 32
417 start = start + 32
418 end = end + 32
418 end = end + 32
419
419
420 tempx = tempx.astype('u4')
420 tempx = tempx.astype('u4')
421 tempx.tofile(fp)
421 tempx.tofile(fp)
422
422
423 # if self.line5Function == RCfunction.FLIP:
423 # if self.line5Function == RCfunction.FLIP:
424 # self.flip1.tofile(fp)
424 # self.flip1.tofile(fp)
425 #
425 #
426 # if self.line6Function == RCfunction.FLIP:
426 # if self.line6Function == RCfunction.FLIP:
427 # self.flip2.tofile(fp)
427 # self.flip2.tofile(fp)
428
428
429 return 1
429 return 1
430
430
431 def get_ippSeconds(self):
431 def get_ippSeconds(self):
432 '''
432 '''
433 '''
433 '''
434 ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
434 ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
435
435
436 return ippSeconds
436 return ippSeconds
437
437
438 def set_ippSeconds(self, ippSeconds):
438 def set_ippSeconds(self, ippSeconds):
439 '''
439 '''
440 '''
440 '''
441
441
442 self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
442 self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
443
443
444 return
444 return
445
445
446 def get_size(self):
446 def get_size(self):
447
447
448 self.__size = 116 + 12*self.nWindows + 4*self.numTaus
448 self.__size = 116 + 12*self.nWindows + 4*self.numTaus
449
449
450 if self.codeType != 0:
450 if self.codeType != 0:
451 self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
451 self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
452
452
453 return self.__size
453 return self.__size
454
454
455 def set_size(self, value):
455 def set_size(self, value):
456
456
457 raise IOError, "size is a property and it cannot be set, just read"
457 raise IOError, "size is a property and it cannot be set, just read"
458
458
459 return
459 return
460
460
461 ippSeconds = property(get_ippSeconds, set_ippSeconds)
461 ippSeconds = property(get_ippSeconds, set_ippSeconds)
462 size = property(get_size, set_size)
462 size = property(get_size, set_size)
463
463
464 class ProcessingHeader(Header):
464 class ProcessingHeader(Header):
465
465
466 # size = None
466 # size = None
467 dtype = None
467 dtype = None
468 blockSize = None
468 blockSize = None
469 profilesPerBlock = None
469 profilesPerBlock = None
470 dataBlocksPerFile = None
470 dataBlocksPerFile = None
471 nWindows = None
471 nWindows = None
472 processFlags = None
472 processFlags = None
473 nCohInt = None
473 nCohInt = None
474 nIncohInt = None
474 nIncohInt = None
475 totalSpectra = None
475 totalSpectra = None
476
476
477 flag_dc = None
477 flag_dc = None
478 flag_cspc = None
478 flag_cspc = None
479
479
480 def __init__(self):
480 def __init__(self):
481
481
482 # self.size = 0
482 # self.size = 0
483 self.dtype = 0
483 self.dtype = 0
484 self.blockSize = 0
484 self.blockSize = 0
485 self.profilesPerBlock = 0
485 self.profilesPerBlock = 0
486 self.dataBlocksPerFile = 0
486 self.dataBlocksPerFile = 0
487 self.nWindows = 0
487 self.nWindows = 0
488 self.processFlags = 0
488 self.processFlags = 0
489 self.nCohInt = 0
489 self.nCohInt = 0
490 self.nIncohInt = 0
490 self.nIncohInt = 0
491 self.totalSpectra = 0
491 self.totalSpectra = 0
492
492
493 self.nHeights = 0
493 self.nHeights = 0
494 self.firstHeight = 0
494 self.firstHeight = 0
495 self.deltaHeight = 0
495 self.deltaHeight = 0
496 self.samplesWin = 0
496 self.samplesWin = 0
497 self.spectraComb = 0
497 self.spectraComb = 0
498 self.nCode = None
498 self.nCode = None
499 self.code = None
499 self.code = None
500 self.nBaud = None
500 self.nBaud = None
501
501
502 self.shif_fft = False
502 self.shif_fft = False
503 self.flag_dc = False
503 self.flag_dc = False
504 self.flag_cspc = False
504 self.flag_cspc = False
505 self.flag_decode = False
505 self.flag_decode = False
506 self.flag_deflip = False
506 self.flag_deflip = False
507
507
508 def read(self, fp):
508 def read(self, fp):
509
509
510 startFp = fp.tell()
510 startFp = fp.tell()
511
511
512 try:
512 try:
513 header = numpy.fromfile(fp,PROCESSING_STRUCTURE,1)
513 header = numpy.fromfile(fp,PROCESSING_STRUCTURE,1)
514 except Exception, e:
514 except Exception, e:
515 print "ProcessingHeader: " + e
515 print "ProcessingHeader: " + e
516 return 0
516 return 0
517
517
518 size = int(header['nSize'][0])
518 size = int(header['nSize'][0])
519 self.dtype = int(header['nDataType'][0])
519 self.dtype = int(header['nDataType'][0])
520 self.blockSize = int(header['nSizeOfDataBlock'][0])
520 self.blockSize = int(header['nSizeOfDataBlock'][0])
521 self.profilesPerBlock = int(header['nProfilesperBlock'][0])
521 self.profilesPerBlock = int(header['nProfilesperBlock'][0])
522 self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
522 self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
523 self.nWindows = int(header['nNumWindows'][0])
523 self.nWindows = int(header['nNumWindows'][0])
524 self.processFlags = header['nProcessFlags']
524 self.processFlags = header['nProcessFlags']
525 self.nCohInt = int(header['nCoherentIntegrations'][0])
525 self.nCohInt = int(header['nCoherentIntegrations'][0])
526 self.nIncohInt = int(header['nIncoherentIntegrations'][0])
526 self.nIncohInt = int(header['nIncoherentIntegrations'][0])
527 self.totalSpectra = int(header['nTotalSpectra'][0])
527 self.totalSpectra = int(header['nTotalSpectra'][0])
528
528
529 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
529 samplingWindow = numpy.fromfile(fp,SAMPLING_STRUCTURE,self.nWindows)
530
530
531 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
531 self.nHeights = int(numpy.sum(samplingWindow['nsa']))
532 self.firstHeight = float(samplingWindow['h0'][0])
532 self.firstHeight = float(samplingWindow['h0'][0])
533 self.deltaHeight = float(samplingWindow['dh'][0])
533 self.deltaHeight = float(samplingWindow['dh'][0])
534 self.samplesWin = samplingWindow['nsa'][0]
534 self.samplesWin = samplingWindow['nsa'][0]
535
535
536 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
536 self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
537
537
538 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
538 if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
539 self.nCode = int(numpy.fromfile(fp,'<u4',1))
539 self.nCode = int(numpy.fromfile(fp,'<u4',1))
540 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
540 self.nBaud = int(numpy.fromfile(fp,'<u4',1))
541 self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
541 self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
542
542
543 if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
543 if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
544 exp_name_len = int(numpy.fromfile(fp,'<u4',1))
544 exp_name_len = int(numpy.fromfile(fp,'<u4',1))
545 exp_name = numpy.fromfile(fp,'u1',exp_name_len+1)
545 exp_name = numpy.fromfile(fp,'u1',exp_name_len+1)
546
546
547 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
547 if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
548 self.shif_fft = True
548 self.shif_fft = True
549 else:
549 else:
550 self.shif_fft = False
550 self.shif_fft = False
551
551
552 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
552 if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
553 self.flag_dc = True
553 self.flag_dc = True
554 else:
554 else:
555 self.flag_dc = False
555 self.flag_dc = False
556
556
557 if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
557 if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
558 self.flag_decode = True
558 self.flag_decode = True
559 else:
559 else:
560 self.flag_decode = False
560 self.flag_decode = False
561
561
562 if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
562 if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
563 self.flag_deflip = True
563 self.flag_deflip = True
564 else:
564 else:
565 self.flag_deflip = False
565 self.flag_deflip = False
566
566
567 nChannels = 0
567 nChannels = 0
568 nPairs = 0
568 nPairs = 0
569 pairList = []
569 pairList = []
570
570
571 for i in range( 0, self.totalSpectra*2, 2 ):
571 for i in range( 0, self.totalSpectra*2, 2 ):
572 if self.spectraComb[i] == self.spectraComb[i+1]:
572 if self.spectraComb[i] == self.spectraComb[i+1]:
573 nChannels = nChannels + 1 #par de canales iguales
573 nChannels = nChannels + 1 #par de canales iguales
574 else:
574 else:
575 nPairs = nPairs + 1 #par de canales diferentes
575 nPairs = nPairs + 1 #par de canales diferentes
576 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
576 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
577
577
578 self.flag_cspc = False
578 self.flag_cspc = False
579 if nPairs > 0:
579 if nPairs > 0:
580 self.flag_cspc = True
580 self.flag_cspc = True
581
581
582 endFp = size + startFp
582 endFp = size + startFp
583
583
584 if fp.tell() > endFp:
584 if fp.tell() > endFp:
585 sys.stderr.write("Warning: Processing header size is lower than it has to be")
585 sys.stderr.write("Warning: Processing header size is lower than it has to be")
586 return 0
586 return 0
587
587
588 if fp.tell() < endFp:
588 if fp.tell() < endFp:
589 sys.stderr.write("Warning: Processing header size is greater than it is considered")
589 sys.stderr.write("Warning: Processing header size is greater than it is considered")
590
590
591 return 1
591 return 1
592
592
593 def write(self, fp):
593 def write(self, fp):
594 #Clear DEFINE_PROCESS_CODE
594 #Clear DEFINE_PROCESS_CODE
595 self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
595 self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
596
596
597 headerTuple = (self.size,
597 headerTuple = (self.size,
598 self.dtype,
598 self.dtype,
599 self.blockSize,
599 self.blockSize,
600 self.profilesPerBlock,
600 self.profilesPerBlock,
601 self.dataBlocksPerFile,
601 self.dataBlocksPerFile,
602 self.nWindows,
602 self.nWindows,
603 self.processFlags,
603 self.processFlags,
604 self.nCohInt,
604 self.nCohInt,
605 self.nIncohInt,
605 self.nIncohInt,
606 self.totalSpectra)
606 self.totalSpectra)
607
607
608 header = numpy.array(headerTuple,PROCESSING_STRUCTURE)
608 header = numpy.array(headerTuple,PROCESSING_STRUCTURE)
609 header.tofile(fp)
609 header.tofile(fp)
610
610
611 if self.nWindows != 0:
611 if self.nWindows != 0:
612 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
612 sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
613 samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
613 samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
614 samplingWindow.tofile(fp)
614 samplingWindow.tofile(fp)
615
615
616 if self.totalSpectra != 0:
616 if self.totalSpectra != 0:
617 # spectraComb = numpy.array([],numpy.dtype('u1'))
617 # spectraComb = numpy.array([],numpy.dtype('u1'))
618 spectraComb = self.spectraComb
618 spectraComb = self.spectraComb
619 spectraComb.tofile(fp)
619 spectraComb.tofile(fp)
620
620
621 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
621 # if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
622 nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
622 # nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
623 nCode.tofile(fp)
623 # nCode.tofile(fp)
624
624 #
625 nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
625 # nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
626 nBaud.tofile(fp)
626 # nBaud.tofile(fp)
627
627 #
628 code = self.code.reshape(self.nCode*self.nBaud)
628 # code = self.code.reshape(self.nCode*self.nBaud)
629 code = code.astype(numpy.dtype('<f4'))
629 # code = code.astype(numpy.dtype('<f4'))
630 code.tofile(fp)
630 # code.tofile(fp)
631
631
632 return 1
632 return 1
633
633
634 def get_size(self):
634 def get_size(self):
635
635
636 self.__size = 40 + 12*self.nWindows + 2*self.totalSpectra
636 self.__size = 40 + 12*self.nWindows + 2*self.totalSpectra
637
637
638 if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
638 # if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
639 # self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
639 # self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
640 self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
640 # self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
641
641
642 return self.__size
642 return self.__size
643
643
644 def set_size(self, value):
644 def set_size(self, value):
645
645
646 raise IOError, "size is a property and it cannot be set, just read"
646 raise IOError, "size is a property and it cannot be set, just read"
647
647
648 return
648 return
649
649
650 size = property(get_size, set_size)
650 size = property(get_size, set_size)
651
651
652 class RCfunction:
652 class RCfunction:
653 NONE=0
653 NONE=0
654 FLIP=1
654 FLIP=1
655 CODE=2
655 CODE=2
656 SAMPLING=3
656 SAMPLING=3
657 LIN6DIV256=4
657 LIN6DIV256=4
658 SYNCHRO=5
658 SYNCHRO=5
659
659
660 class nCodeType:
660 class nCodeType:
661 NONE=0
661 NONE=0
662 USERDEFINE=1
662 USERDEFINE=1
663 BARKER2=2
663 BARKER2=2
664 BARKER3=3
664 BARKER3=3
665 BARKER4=4
665 BARKER4=4
666 BARKER5=5
666 BARKER5=5
667 BARKER7=6
667 BARKER7=6
668 BARKER11=7
668 BARKER11=7
669 BARKER13=8
669 BARKER13=8
670 AC128=9
670 AC128=9
671 COMPLEMENTARYCODE2=10
671 COMPLEMENTARYCODE2=10
672 COMPLEMENTARYCODE4=11
672 COMPLEMENTARYCODE4=11
673 COMPLEMENTARYCODE8=12
673 COMPLEMENTARYCODE8=12
674 COMPLEMENTARYCODE16=13
674 COMPLEMENTARYCODE16=13
675 COMPLEMENTARYCODE32=14
675 COMPLEMENTARYCODE32=14
676 COMPLEMENTARYCODE64=15
676 COMPLEMENTARYCODE64=15
677 COMPLEMENTARYCODE128=16
677 COMPLEMENTARYCODE128=16
678 CODE_BINARY28=17
678 CODE_BINARY28=17
679
679
680 class PROCFLAG:
680 class PROCFLAG:
681
681
682 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
682 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
683 DECODE_DATA = numpy.uint32(0x00000002)
683 DECODE_DATA = numpy.uint32(0x00000002)
684 SPECTRA_CALC = numpy.uint32(0x00000004)
684 SPECTRA_CALC = numpy.uint32(0x00000004)
685 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
685 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
686 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
686 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
687 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
687 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
688
688
689 DATATYPE_CHAR = numpy.uint32(0x00000040)
689 DATATYPE_CHAR = numpy.uint32(0x00000040)
690 DATATYPE_SHORT = numpy.uint32(0x00000080)
690 DATATYPE_SHORT = numpy.uint32(0x00000080)
691 DATATYPE_LONG = numpy.uint32(0x00000100)
691 DATATYPE_LONG = numpy.uint32(0x00000100)
692 DATATYPE_INT64 = numpy.uint32(0x00000200)
692 DATATYPE_INT64 = numpy.uint32(0x00000200)
693 DATATYPE_FLOAT = numpy.uint32(0x00000400)
693 DATATYPE_FLOAT = numpy.uint32(0x00000400)
694 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
694 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
695
695
696 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
696 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
697 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
697 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
698 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
698 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
699
699
700 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
700 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
701 DEFLIP_DATA = numpy.uint32(0x00010000)
701 DEFLIP_DATA = numpy.uint32(0x00010000)
702 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
702 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
703
703
704 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
704 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
705 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
705 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
706 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
706 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
707 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
707 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
708 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
708 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
709
709
710 EXP_NAME_ESP = numpy.uint32(0x00200000)
710 EXP_NAME_ESP = numpy.uint32(0x00200000)
711 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
711 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
712
712
713 OPERATION_MASK = numpy.uint32(0x0000003F)
713 OPERATION_MASK = numpy.uint32(0x0000003F)
714 DATATYPE_MASK = numpy.uint32(0x00000FC0)
714 DATATYPE_MASK = numpy.uint32(0x00000FC0)
715 DATAARRANGE_MASK = numpy.uint32(0x00007000)
715 DATAARRANGE_MASK = numpy.uint32(0x00007000)
716 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
716 ACQ_SYS_MASK = numpy.uint32(0x001C0000)
717
717
718 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
718 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
719 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
719 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
720 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
720 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
721 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
721 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
722 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
722 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
723 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
723 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
724
724
725 NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
725 NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
726
726
727 PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR,
727 PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR,
728 PROCFLAG.DATATYPE_SHORT,
728 PROCFLAG.DATATYPE_SHORT,
729 PROCFLAG.DATATYPE_LONG,
729 PROCFLAG.DATATYPE_LONG,
730 PROCFLAG.DATATYPE_INT64,
730 PROCFLAG.DATATYPE_INT64,
731 PROCFLAG.DATATYPE_FLOAT,
731 PROCFLAG.DATATYPE_FLOAT,
732 PROCFLAG.DATATYPE_DOUBLE]
732 PROCFLAG.DATATYPE_DOUBLE]
733
733
734 DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
734 DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
735
735
736 def get_dtype_index(numpy_dtype):
736 def get_dtype_index(numpy_dtype):
737
737
738 index = None
738 index = None
739
739
740 for i in range(len(NUMPY_DTYPE_LIST)):
740 for i in range(len(NUMPY_DTYPE_LIST)):
741 if numpy_dtype == NUMPY_DTYPE_LIST[i]:
741 if numpy_dtype == NUMPY_DTYPE_LIST[i]:
742 index = i
742 index = i
743 break
743 break
744
744
745 return index
745 return index
746
746
747 def get_numpy_dtype(index):
747 def get_numpy_dtype(index):
748
748
749 return NUMPY_DTYPE_LIST[index]
749 return NUMPY_DTYPE_LIST[index]
750
750
751 def get_procflag_dtype(index):
751 def get_procflag_dtype(index):
752
752
753 return PROCFLAG_DTYPE_LIST[index]
753 return PROCFLAG_DTYPE_LIST[index]
754
754
755 def get_dtype_width(index):
755 def get_dtype_width(index):
756
756
757 return DTYPE_WIDTH[index] No newline at end of file
757 return DTYPE_WIDTH[index]
General Comments 0
You need to be logged in to leave comments. Login now