##// END OF EJS Templates
schain
RSS
Version con Lectura de Pdata y RawData operando correctamente,tambien la Escritura de Rawdata....
Daniel Valdez -
r124:5a0951cb35e4
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,388
1 '''
2 Created on Feb 7, 2012
3
4 @author $Author: murco $
5 @version $Id: SpectraProcessor.py 119 2012-09-05 17:06:09Z murco $
6 '''
7 import os, sys
8 import numpy
9 import time
10
11 path = os.path.split(os.getcwd())[0]
12 sys.path.append(path)
13
14 from Data.Spectra import Spectra
15 from IO.SpectraIO import SpectraWriter
16 #from Graphics.SpectraPlot import Spectrum
17 #from JRONoise import Noise
18
19 class SpectraProcessor:
20 '''
21 classdocs
22 '''
23
24 dataInObj = None
25
26 dataOutObj = None
27
28 noiseObj = None
29
30 integratorObjList = []
31
32 writerObjList = []
33
34 integratorObjIndex = None
35
36 writerObjIndex = None
37
38 profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
39
40 # integratorObjList = []
41 #
42 # decoderObjList = []
43 #
44 # writerObjList = []
45 #
46 # plotterObjList = []
47 #
48 # integratorObjIndex = None
49 #
50 # decoderObjIndex = None
51 #
52 # writerObjIndex = None
53 #
54 # plotterObjIndex = None
55 #
56 # buffer = None
57 #
58 # profIndex = 0
59 #
60 # nFFTPoints = None
61 #
62 # nChannels = None
63 #
64 # nHeights = None
65 #
66 # nPairs = None
67 #
68 # pairList = None
69
70
71 def __init__(self):
72 '''
73 Constructor
74 '''
75
76 self.integratorObjIndex = None
77 self.writerObjIndex = None
78 self.integratorObjList = []
79 self.writerObjList = []
80 self.noiseObj = None
81 self.buffer = None
82 self.profIndex = 0
83
84 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
85
86 if dataInObj == None:
87 raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
88
89 if dataInObj.type == "Voltage":
90 if nFFTPoints == None:
91 raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
92 else:
93 nFFTPoints = dataInObj.nFFTPoints
94
95 self.dataInObj = dataInObj
96
97 if dataOutObj == None:
98 dataOutObj = Spectra()
99
100 self.dataOutObj = dataOutObj
101
102 # self.noiseObj = Noise() #aun no se incluye el objeto Noise()
103
104 ##########################################
105 # self.nFFTPoints = nFFTPoints
106 # self.nChannels = self.dataInObj.nChannels
107 # self.nHeights = self.dataInObj.nHeights
108 # self.pairList = pairList
109 # if pairList != None:
110 # self.nPairs = len(pairList)
111 # else:
112 # self.nPairs = 0
113 #
114 # self.dataOutObj.heightList = self.dataInObj.heightList
115 # self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
116 # self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
117 # self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
118 # self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
119 # self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
120 #
121 # self.dataOutObj.dataType = self.dataInObj.dataType
122 # self.dataOutObj.nPairs = self.nPairs
123 # self.dataOutObj.nChannels = self.nChannels
124 # self.dataOutObj.nProfiles = self.nFFTPoints
125 # self.dataOutObj.nHeights = self.nHeights
126 # self.dataOutObj.nFFTPoints = self.nFFTPoints
127 # #self.dataOutObj.data = None
128 #
129 # self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
130 # self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
131 #
132 # self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
133 # self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
134 # self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
135 # self.dataOutObj.m_ProcessingHeader.shif_fft = True
136 #
137 # spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
138 # k = 0
139 # for i in range( 0,self.nChannels*2,2 ):
140 # spectraComb[i] = k
141 # spectraComb[i+1] = k
142 # k += 1
143 #
144 # k *= 2
145 #
146 # if self.pairList != None:
147 #
148 # for pair in self.pairList:
149 # spectraComb[k] = pair[0]
150 # spectraComb[k+1] = pair[1]
151 # k += 2
152 #
153 # self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
154
155 return self.dataOutObj
156
157 def init(self):
158 #
159 # self.nHeights = self.dataInObj.nHeights
160 # self.dataOutObj.nHeights = self.nHeights
161 # self.dataOutObj.heightList = self.dataInObj.heightList
162 #
163
164 self.integratorObjIndex = 0
165 self.writerObjIndex = 0
166
167 if self.dataInObj.type == "Voltage":
168
169 if self.buffer == None:
170 self.buffer = numpy.zeros((self.nChannels,
171 self.nFFTPoints,
172 self.dataInObj.nHeights),
173 dtype='complex')
174
175 self.buffer[:,self.profIndex,:] = self.dataInObj.data
176 self.profIndex += 1
177
178 if self.profIndex == self.nFFTPoints:
179 self.__getFft()
180 self.dataOutObj.flagNoData = False
181
182 self.buffer = None
183 self.profIndex = 0
184 return
185
186 self.dataOutObj.flagNoData = True
187
188 return
189
190 #Other kind of data
191 if self.dataInObj.type == "Spectra":
192 self.dataOutObj.copy(self.dataInObj)
193 self.dataOutObj.flagNoData = False
194 return
195
196 raise ValueError, "The datatype is not valid"
197
198 def __getFft(self):
199 """
200 Convierte valores de Voltaje a Spectra
201
202 Affected:
203 self.dataOutObj.data_spc
204 self.dataOutObj.data_cspc
205 self.dataOutObj.data_dc
206 self.dataOutObj.heightList
207 self.dataOutObj.m_BasicHeader
208 self.dataOutObj.m_ProcessingHeader
209 self.dataOutObj.m_RadarControllerHeader
210 self.dataOutObj.m_SystemHeader
211 self.profIndex
212 self.buffer
213 self.dataOutObj.flagNoData
214 self.dataOutObj.dataType
215 self.dataOutObj.nPairs
216 self.dataOutObj.nChannels
217 self.dataOutObj.nProfiles
218 self.dataOutObj.m_SystemHeader.numChannels
219 self.dataOutObj.m_ProcessingHeader.totalSpectra
220 self.dataOutObj.m_ProcessingHeader.profilesPerBlock
221 self.dataOutObj.m_ProcessingHeader.numHeights
222 self.dataOutObj.m_ProcessingHeader.spectraComb
223 self.dataOutObj.m_ProcessingHeader.shif_fft
224 """
225
226 if self.dataInObj.flagNoData:
227 return 0
228
229 fft_volt = numpy.fft.fft(self.buffer,axis=1)
230 dc = fft_volt[:,0,:]
231
232 #calculo de self-spectra
233 fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
234 spc = fft_volt * numpy.conjugate(fft_volt)
235 spc = spc.real
236
237 blocksize = 0
238 blocksize += dc.size
239 blocksize += spc.size
240
241 cspc = None
242 pairIndex = 0
243 if self.pairList != None:
244 #calculo de cross-spectra
245 cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
246 for pair in self.pairList:
247 cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
248 pairIndex += 1
249 blocksize += cspc.size
250
251 self.dataOutObj.data_spc = spc
252 self.dataOutObj.data_cspc = cspc
253 self.dataOutObj.data_dc = dc
254 self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
255 self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
256
257 # self.getNoise()
258
259 def addWriter(self, wrpath, profilesPerBlock, blocksPerFile):
260 objWriter = SpectraWriter(self.dataOutObj, pairList)
261 objWriter.setup(wrpath, profilesPerBlock, blocksPerFile)
262 self.writerObjList.append(objWriter)
263
264 def addIntegrator(self,N,timeInterval):
265
266 objIncohInt = IncoherentIntegration(N,timeInterval)
267 self.integratorObjList.append(objIncohInt)
268
269 def writeData(self, wrpath, profilesPerBlock, blocksPerFile):
270 if self.dataOutObj.flagNoData:
271 return 0
272
273 if len(self.writerObjList) <= self.writerObjIndex:
274 self.addWriter(wrpath, profilesPerBlock, blocksPerFile)
275
276 self.writerObjList[self.writerObjIndex].putData()
277
278 self.writerObjIndex += 1
279
280 def integrator(self, N=None, timeInterval=None):
281
282 if self.dataOutObj.flagNoData:
283 return 0
284
285 if len(self.integratorObjList) <= self.integratorObjIndex:
286 self.addIntegrator(N,timeInterval)
287
288 myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
289 myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
290
291 if myIncohIntObj.isReady:
292 self.dataOutObj.data_spc = myIncohIntObj.data
293 self.dataOutObj.nAvg = myIncohIntObj.navg
294 self.dataOutObj.m_ProcessingHeader.incoherentInt = self.dataInObj.m_ProcessingHeader.incoherentInt*myIncohIntObj.navg
295 #print "myIncohIntObj.navg: ",myIncohIntObj.navg
296 self.dataOutObj.flagNoData = False
297
298 """Calcular el ruido"""
299 self.getNoise()
300 else:
301 self.dataOutObj.flagNoData = True
302
303 self.integratorObjIndex += 1
304
305
306
307
308 class IncoherentIntegration:
309
310 integ_counter = None
311 data = None
312 navg = None
313 buffer = None
314 nIncohInt = None
315
316 def __init__(self, N = None, timeInterval = None):
317 """
318 N
319 timeInterval - interval time [min], integer value
320 """
321
322 self.data = None
323 self.navg = None
324 self.buffer = None
325 self.timeOut = None
326 self.exitCondition = False
327 self.isReady = False
328 self.nIncohInt = N
329 self.integ_counter = 0
330 if timeInterval!=None:
331 self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
332
333 if ((timeInterval==None) and (N==None)):
334 print 'N = None ; timeInterval = None'
335 sys.exit(0)
336 elif timeInterval == None:
337 self.timeFlag = False
338 else:
339 self.timeFlag = True
340
341
342 def exe(self,data,timeOfData):
343 """
344 data
345
346 timeOfData [seconds]
347 """
348
349 if self.timeFlag:
350 if self.timeOut == None:
351 self.timeOut = timeOfData + self.timeIntervalInSeconds
352
353 if timeOfData < self.timeOut:
354 if self.buffer == None:
355 self.buffer = data
356 else:
357 self.buffer = self.buffer + data
358 self.integ_counter += 1
359 else:
360 self.exitCondition = True
361
362 else:
363 if self.integ_counter < self.nIncohInt:
364 if self.buffer == None:
365 self.buffer = data
366 else:
367 self.buffer = self.buffer + data
368
369 self.integ_counter += 1
370
371 if self.integ_counter == self.nIncohInt:
372 self.exitCondition = True
373
374 if self.exitCondition:
375 self.data = self.buffer
376 self.navg = self.integ_counter
377 self.isReady = True
378 self.buffer = None
379 self.timeOut = None
380 self.integ_counter = 0
381 self.exitCondition = False
382
383 if self.timeFlag:
384 self.buffer = data
385 self.timeOut = timeOfData + self.timeIntervalInSeconds
386 else:
387 self.isReady = False
388 No newline at end of file
Show file before | Show file after | Hide comments
@@ -46,6 +46,13 class JROData:
46 46
47 47 code = None
48 48
49 flagDecodeData = True #asumo q la data esta decodificada
50
51 flagDeflipData = True #asumo q la data esta sin flip
52
53 flagShiftFFT = False
54
55
49 56 def __init__(self):
50 57
51 58 raise ValueError, "This class has not been implemented"
Show file before | Show file after | Hide comments
@@ -488,6 +488,8 class JRODataWriter(JRODataIO):
488 488
489 489 blocksPerFile = None
490 490
491 nWriteBlocks = 0
492
491 493 def __init__(self, dataOutObj=None):
492 494 raise ValueError, "Not implemented"
493 495
@@ -521,8 +523,8 class JRODataWriter(JRODataIO):
521 523
522 524 # CALCULAR PARAMETROS
523 525
524 sizeLongHeader = 0#XXXX
525 self.basicHeaderObj.size = 24 + sizeLongHeader
526 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
527 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
526 528
527 529 self.__writeBasicHeader()
528 530 self.__wrSystemHeader()
@@ -541,7 +543,7 class JRODataWriter(JRODataIO):
541 543 if fp == None:
542 544 fp = self.fp
543 545
544 self.dataOutObj.basicHeaderObj.write(fp)
546 self.basicHeaderObj.write(fp)
545 547
546 548
547 549 def __wrSystemHeader(self, fp=None):
@@ -554,7 +556,7 class JRODataWriter(JRODataIO):
554 556 if fp == None:
555 557 fp = self.fp
556 558
557 self.dataOutObj.systemHeaderObj.write(fp)
559 self.systemHeaderObj.write(fp)
558 560
559 561
560 562 def __wrRadarControllerHeader(self, fp=None):
@@ -567,7 +569,7 class JRODataWriter(JRODataIO):
567 569 if fp == None:
568 570 fp = self.fp
569 571
570 self.dataOutObj.radarControllerHeaderObj.write(fp)
572 self.radarControllerHeaderObj.write(fp)
571 573
572 574
573 575 def __wrProcessingHeader(self, fp=None):
@@ -580,7 +582,7 class JRODataWriter(JRODataIO):
580 582 if fp == None:
581 583 fp = self.fp
582 584
583 self.dataOutObj.processingHeaderObj.write(fp)
585 self.processingHeaderObj.write(fp)
584 586
585 587
586 588 def setNextFile(self):
@@ -648,6 +650,8 class JRODataWriter(JRODataIO):
648 650 self.setFile = setFile
649 651 self.flagIsNewFile = 1
650 652
653 self.getDataHeader()
654
651 655 print 'Writing the file: %s'%self.filename
652 656
653 657 self.__writeFirstHeader()
@@ -732,18 +736,12 class JRODataWriter(JRODataIO):
732 736
733 737 self.blocksPerFile = blocksPerFile
734 738
735
736
737
738
739 self.getDataHeader()
740
741 self.setBlockDimension()
742
743 739 if not( self.setNextFile() ):
744 740 print "There isn't a next file"
745 741 return 0
746 742
743 self.setBlockDimension()
744
747 745 return 1
748 746
749 747
Show file before | Show file after | Hide comments
@@ -341,9 +341,9 class ProcessingHeader(Header):
341 341 self.deltaHeight = 0
342 342 self.samplesWin = 0
343 343 self.spectraComb = 0
344 self.nCode = 0
345 self.code = 0
346 self.nBaud = 0
344 self.nCode = None
345 self.code = None
346 self.nBaud = None
347 347 self.shif_fft = False
348 348 self.flag_dc = False
349 349 self.flag_cspc = False
Show file before | Show file after | Hide comments
@@ -369,6 +369,8 class SpectraReader(JRODataReader):
369 369
370 370 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc #+ self.profileIndex * self.ippSeconds
371 371
372 self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
373
372 374 # self.profileIndex += 1
373 375
374 376 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -385,11 +387,29 class SpectraWriter(JRODataWriter):
385 387 de los datos siempre se realiza por bloques.
386 388 """
387 389
390 ext = ".pdata"
391
392 optchar = "P"
388 393
389 394 shape_spc_Buffer = None
395
390 396 shape_cspc_Buffer = None
397
391 398 shape_dc_Buffer = None
392 dataOutObj = None
399
400 data_spc = None
401
402 data_cspc = None
403
404 data_dc = None
405
406 wrPairList = []
407
408 nWrPairs = 0
409
410 nWrChannels = 0
411
412 # dataOutObj = None
393 413
394 414 def __init__(self, dataOutObj=None):
395 415 """
@@ -412,49 +432,54 class SpectraWriter(JRODataWriter):
412 432
413 433 self.dataOutObj = dataOutObj
414 434
415 self.ext = ".pdata"
416
417 self.optchar = "P"
418
419 self.shape_spc_Buffer = None
420 self.shape_cspc_Buffer = None
421 self.shape_dc_Buffer = None
422
423 self.data_spc = None
424 self.data_cspc = None
425 self.data_dc = None
426
427 ####################################
428
429 self.fp = None
430
431 self.nWriteBlocks = 0
432
433 self.flagIsNewFile = 1
434
435 435 self.nTotalBlocks = 0
436 436
437 self.flagIsNewBlock = 0
437 self.nWrChannels = self.dataOutObj.nChannels
438 438
439 self.flagNoMoreFiles = 0
439 # if len(pairList) > 0:
440 # self.wrPairList = pairList
441 #
442 # self.nWrPairs = len(pairList)
440 443
441 self.setFile = None
444 self.wrPairList = self.dataOutObj.pairList
442 445
443 self.dtype = None
446 self.nWrPairs = self.dataOutObj.nPairs
444 447
445 self.path = None
446 448
447 self.noMoreFiles = 0
448 449
449 self.filename = None
450 450
451 self.basicHeaderObj = BasicHeader()
452 451
453 self.systemHeaderObj = SystemHeader()
452 # self.data_spc = None
453 # self.data_cspc = None
454 # self.data_dc = None
454 455
455 self.radarControllerHeaderObj = RadarControllerHeader()
456 # self.fp = None
456 457
457 self.processingHeaderObj = ProcessingHeader()
458 # self.flagIsNewFile = 1
459 #
460 # self.nTotalBlocks = 0
461 #
462 # self.flagIsNewBlock = 0
463 #
464 # self.flagNoMoreFiles = 0
465 #
466 # self.setFile = None
467 #
468 # self.dtype = None
469 #
470 # self.path = None
471 #
472 # self.noMoreFiles = 0
473 #
474 # self.filename = None
475 #
476 # self.basicHeaderObj = BasicHeader()
477 #
478 # self.systemHeaderObj = SystemHeader()
479 #
480 # self.radarControllerHeaderObj = RadarControllerHeader()
481 #
482 # self.processingHeaderObj = ProcessingHeader()
458 483
459 484
460 485 def hasAllDataInBuffer(self):
@@ -572,3 +597,152 class SpectraWriter(JRODataWriter):
572 597 return 0
573 598
574 599 return 1
600
601
602 def __getProcessFlags(self):
603
604 processFlags = 0
605
606 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
607 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
608 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
609 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
610 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
611 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
612
613 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
614
615
616
617 datatypeValueList = [PROCFLAG.DATATYPE_CHAR,
618 PROCFLAG.DATATYPE_SHORT,
619 PROCFLAG.DATATYPE_LONG,
620 PROCFLAG.DATATYPE_INT64,
621 PROCFLAG.DATATYPE_FLOAT,
622 PROCFLAG.DATATYPE_DOUBLE]
623
624
625 for index in range(len(dtypeList)):
626 if self.dataOutObj.dtype == dtypeList[index]:
627 dtypeValue = datatypeValueList[index]
628 break
629
630 processFlags += dtypeValue
631
632 if self.dataOutObj.flagDecodeData:
633 processFlags += PROCFLAG.DECODE_DATA
634
635 if self.dataOutObj.flagDeflipData:
636 processFlags += PROCFLAG.DEFLIP_DATA
637
638 if self.dataOutObj.code != None:
639 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
640
641 if self.dataOutObj.nIncohInt > 1:
642 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
643
644 if self.dataOutObj.data_dc != None:
645 processFlags += PROCFLAG.SAVE_CHANNELS_DC
646
647 return processFlags
648
649
650 def __getBlockSize(self):
651 '''
652 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
653 '''
654
655 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
656 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
657 dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
658 dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
659 dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
660 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
661
662 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
663 datatypeValueList = [1,2,4,8,4,8]
664 for index in range(len(dtypeList)):
665 if self.dataOutObj.dtype == dtypeList[index]:
666 datatypeValue = datatypeValueList[index]
667 break
668
669
670 pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
671
672 pts2write_SelfSpectra = int(self.nWrChannels * pts2write)
673 blocksize = pts2write_SelfSpectra
674
675 if self.dataOutObj.data_cspc != None:
676 pts2write_CrossSpectra = int(self.nWrPairs * pts2write)
677 blocksize += pts2write_CrossSpectra
678
679 if self.dataOutObj.data_dc != None:
680 pts2write_DCchannels = int(self.nWrChannels * self.dataOutObj.nHeights)
681 blocksize += pts2write_DCchannels
682
683 blocksize = blocksize * datatypeValue * 2
684
685 return blocksize
686
687
688 def getBasicHeader(self):
689 self.basicHeaderObj.size = self.basicHeaderSize #bytes
690 self.basicHeaderObj.version = self.versionFile
691 self.basicHeaderObj.dataBlock = self.nTotalBlocks
692
693 utc = numpy.floor(self.dataOutObj.dataUtcTime)
694 milisecond = (self.dataOutObj.dataUtcTime - utc)* 1000.0
695
696 self.basicHeaderObj.utc = utc
697 self.basicHeaderObj.miliSecond = milisecond
698 self.basicHeaderObj.timeZone = 0
699 self.basicHeaderObj.dstFlag = 0
700 self.basicHeaderObj.errorCount = 0
701
702 def getDataHeader(self):
703
704 """
705 Obtiene una copia del First Header
706
707 Affected:
708 self.systemHeaderObj
709 self.radarControllerHeaderObj
710 self.dtype
711
712 Return:
713 None
714 """
715
716 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
717 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
718
719 self.getBasicHeader()
720
721 processingHeaderSize = 40 # bytes
722 self.processingHeaderObj.dtype = 0 # Voltage
723 self.processingHeaderObj.blockSize = self.__getBlockSize()
724 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
725 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
726 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
727 self.processingHeaderObj.processFlags = self.__getProcessFlags()
728 self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
729 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
730 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
731
732 if self.dataOutObj.code != None:
733 self.processingHeaderObj.code = self.dataOutObj.code
734 self.processingHeaderObj.nCode = self.dataOutObj.nCode
735 self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
736 codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
737 processingHeaderSize += codesize
738
739 if self.processingHeaderObj.nWindows != 0:
740 self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
741 self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
742 self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
743 self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
744 processingHeaderSize += 12
745
746 self.processingHeaderObj.size = processingHeaderSize
747
748 No newline at end of file
Show file before | Show file after | Hide comments
@@ -298,6 +298,15 class VoltageReader(JRODataReader):
298 298
299 299 self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
300 300
301 self.dataOutObj.flagShiftFFT = False
302
303 if self.processingHeaderObj.code != None:
304 self.dataOutObj.nCode = self.processingHeaderObj.nCode
305
306 self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
307
308 self.dataOutObj.code = self.processingHeaderObj.code
309
301 310 self.profileIndex += 1
302 311
303 312 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -339,6 +348,9 class VoltageWriter(JRODataWriter):
339 348
340 349 self.dataOutObj = dataOutObj
341 350
351 self.nTotalBlocks = 0
352
353 self.profileIndex = 0
342 354
343 355 def hasAllDataInBuffer(self):
344 356 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
@@ -423,14 +435,17 class VoltageWriter(JRODataWriter):
423 435 self.profileIndex = 0
424 436 self.setNextFile()
425 437
438 if self.profileIndex == 0:
439 self.getBasicHeader()
440
426 441 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
427 442
428 443 self.profileIndex += 1
429 444
430 445 if self.hasAllDataInBuffer():
431 446 #if self.flagIsNewFile:
432 self.getDataHeader()
433 447 self.writeNextBlock()
448 # self.getDataHeader()
434 449
435 450 if self.flagNoMoreFiles:
436 451 #print 'Process finished'
@@ -438,7 +453,7 class VoltageWriter(JRODataWriter):
438 453
439 454 return 1
440 455
441 def __getProcessFlag(self):
456 def __getProcessFlags(self):
442 457
443 458 processFlags = 0
444 459
@@ -462,7 +477,7 class VoltageWriter(JRODataWriter):
462 477
463 478
464 479 for index in range(len(dtypeList)):
465 if dtypeList == self.dataOutObj.dtype:
480 if self.dataOutObj.dtype == dtypeList[index]:
466 481 dtypeValue = datatypeValueList[index]
467 482 break
468 483
@@ -474,12 +489,19 class VoltageWriter(JRODataWriter):
474 489 if self.dataOutObj.flagDeflipData:
475 490 processFlags += PROCFLAG.DEFLIP_DATA
476 491
492 if self.dataOutObj.code != None:
493 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
494
477 495 if self.dataOutObj.nCohInt > 1:
478 496 processFlags += PROCFLAG.COHERENT_INTEGRATION
479 497
498 return processFlags
480 499
481 def __getBlockSize(self):
482 500
501 def __getBlockSize(self):
502 '''
503 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
504 '''
483 505
484 506 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
485 507 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
@@ -489,16 +511,31 class VoltageWriter(JRODataWriter):
489 511 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
490 512
491 513 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
492 datatypeValueList
514 datatypeValueList = [1,2,4,8,4,8]
493 515 for index in range(len(dtypeList)):
494 if dtypeList == self.dataOutObj.dtype:
495 datatypeValue = index
516 if self.dataOutObj.dtype == dtypeList[index]:
517 datatypeValue = datatypeValueList[index]
496 518 break
497 519
498 self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2
520 blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
499 521
522 return blocksize
500 523
501 524
525 def getBasicHeader(self):
526 self.basicHeaderObj.size = self.basicHeaderSize #bytes
527 self.basicHeaderObj.version = self.versionFile
528 self.basicHeaderObj.dataBlock = self.nTotalBlocks
529
530 utc = numpy.floor(self.dataOutObj.dataUtcTime)
531 milisecond = (self.dataOutObj.dataUtcTime - utc)* 1000.0
532
533 self.basicHeaderObj.utc = utc
534 self.basicHeaderObj.miliSecond = milisecond
535 self.basicHeaderObj.timeZone = 0
536 self.basicHeaderObj.dstFlag = 0
537 self.basicHeaderObj.errorCount = 0
538
502 539 def getDataHeader(self):
503 540
504 541 """
@@ -513,35 +550,35 class VoltageWriter(JRODataWriter):
513 550 None
514 551 """
515 552
516 # CALCULAR PARAMETROS
517
518 553 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
519 554 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
520 555
521 self.basicHeaderObj.size = self.basicHeaderSize #bytes
522 self.basicHeaderObj.version = self.versionFile
523 self.basicHeaderObj.dataBlock = self.nTotalBlocks
524 self.basicHeaderObj.utc = self.dataOutObj.dataUtcTime
525 self.basicHeaderObj.miliSecond = 0
526 self.basicHeaderObj.timeZone = 0
527 self.basicHeaderObj.dstFlag = 0
528 self.basicHeaderObj.errorCount = 0
529
530 staticProcessingHeaderSize = 40 # bytes
531 dynProcessingHeaderSize = 0 # bytes
556 self.getBasicHeader()
532 557
533 self.processingHeaderObj.size = staticProcessingHeaderSize + dynProcessingHeaderSize
558 processingHeaderSize = 40 # bytes
534 559 self.processingHeaderObj.dtype = 0 # Voltage
535 # self.processingHeaderObj.dtype = self.dataOutObj.dtype
536 self.processingHeaderObj.blockSize = 0 # debe calcular el size en bytes del bloque de datos:
537 # usar funcion getBlockSize
538 self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nProfiles
560 self.processingHeaderObj.blockSize = self.__getBlockSize()
561 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
539 562 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
540 self.processingHeaderObj.numWindows = 1
563 self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
541 564 self.processingHeaderObj.processFlags = self.__getProcessFlags()
542 self.processingHeaderObj.coherentInt = self.dataOutObj.nCohInt
543 self.processingHeaderObj.incoherentInt = 1 # Cuando la data de origen sea de tipo Voltage
544 self.processingHeaderObj.totalSpectra = 0
545
546 self.dtype = self.dataOutObj.dtype
565 self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
566 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
567 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
568
569 if self.dataOutObj.code != None:
570 self.processingHeaderObj.code = self.dataOutObj.code
571 self.processingHeaderObj.nCode = self.dataOutObj.nCode
572 self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
573 codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
574 processingHeaderSize += codesize
575
576 if self.processingHeaderObj.nWindows != 0:
577 self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
578 self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
579 self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
580 self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
581 processingHeaderSize += 12
582
583 self.processingHeaderObj.size = processingHeaderSize
547 584 No newline at end of file
Show file before | Show file after | Hide comments
@@ -21,14 +21,22 class TestSChain():
21 21
22 22 def setValues(self):
23 23 self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
24 self.startDate = datetime.date(2011,11,28)
25 self.endDate = datetime.date(2011,11,30)
24 26
27 # self.path = "/Users/danielangelsuarezmunoz/Data/Imaging_rawdata"
28 # self.startDate = datetime.date(2011,10,4)
29 # self.endDate = datetime.date(2011,10,4)
30
31 # Probando los escritos por Signal Chain
32 self.path = "/Users/danielangelsuarezmunoz/Data/testWR"
25 33 self.startDate = datetime.date(2011,11,28)
26 34 self.endDate = datetime.date(2011,11,30)
27 35
28 36 self.startTime = datetime.time(0,0,0)
29 37 self.endTime = datetime.time(23,59,59)
30 38
31 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
39 self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR"
32 40 self.profilesPerBlock = 40
33 41 self.blocksPerFile = 50
34 42
@@ -56,16 +64,17 class TestSChain():
56 64 while(True):
57 65 self.readerObj.getData()
58 66
59 self.voltObjProc.init()
60
61 self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
67 # self.voltObjProc.init()
68 #
69 # self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
62 70
63 71 if self.readerObj.flagNoMoreFiles:
64 72 break
65 73
66 74 if self.readerObj.flagIsNewBlock:
75 # print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
67 76 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
68 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
77 datetime.datetime.utcfromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
69 78
70 79
71 80 if __name__ == '__main__':
Show file before | Show file after | Hide comments
@@ -5,11 +5,10 import time, datetime
5 5 path = os.path.split(os.getcwd())[0]
6 6 sys.path.append(path)
7 7
8 from Data.Voltage import Voltage
8
9 9 from Data.Spectra import Spectra
10 from IO.VoltageIO import *
11 10 from IO.SpectraIO import *
12 from Processing.VoltageProcessor import *
11 from Processing.SpectraProcessor import *
13 12
14 13
15 14
@@ -26,19 +25,24 class TestSChain:
26 25 self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
27 26 self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
28 27
29 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
30
31 28 self.startDate = datetime.date(2012,3,1)
32 29 self.endDate = datetime.date(2012,3,30)
33 30
34 31 self.startTime = datetime.time(0,0,0)
35 32 self.endTime = datetime.time(14,1,1)
36 33
34 # paramatros para Escritura de Pdata
35 self.wrpath = "/Users/danielangelsuarezmunoz/Data/testWR_pdata"
36 self.profilesPerBlock = 16
37 self.blocksPerFile = 5
38 # self.pairList = [(0,1),(0,2)]
39
40
37 41 def createObjects(self):
38 42
39 43 self.readerObj = SpectraReader()
40 44
41 self.voltObj1 = self.readerObj.setup(
45 self.specObj1 = self.readerObj.setup(
42 46 path = self.path,
43 47 startDate = self.startDate,
44 48 endDate = self.endDate,
@@ -46,6 +50,10 class TestSChain:
46 50 endTime = self.endTime,
47 51 expLabel = '',
48 52 online = 0)
53 # new lines
54 self.specObjProc = SpectraProcessor()
55
56 self.specObj2 = self.specObjProc.setup(dataInObj = self.specObj1)
49 57
50 58
51 59
@@ -56,12 +64,16 class TestSChain:
56 64 while(True):
57 65 self.readerObj.getData()
58 66
67 self.specObjProc.init()
68
69 self.specObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
70
59 71 if self.readerObj.flagNoMoreFiles:
60 72 break
61 73
62 74 if self.readerObj.flagIsNewBlock:
63 75 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
64 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
76 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc))
65 77
66 78
67 79 if __name__ == '__main__':
General Comments 0
You need to be logged in to leave comments. Login now