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