##// 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
@@ -45,6 +45,13 class JROData:
45 nBaud = None
45 nBaud = None
46
46
47 code = None
47 code = None
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
48
55
49 def __init__(self):
56 def __init__(self):
50
57
Show file before | Show file after | Hide comments
@@ -488,6 +488,8 class JRODataWriter(JRODataIO):
488
488
489 blocksPerFile = None
489 blocksPerFile = None
490
490
491 nWriteBlocks = 0
492
491 def __init__(self, dataOutObj=None):
493 def __init__(self, dataOutObj=None):
492 raise ValueError, "Not implemented"
494 raise ValueError, "Not implemented"
493
495
@@ -521,8 +523,8 class JRODataWriter(JRODataIO):
521
523
522 # CALCULAR PARAMETROS
524 # CALCULAR PARAMETROS
523
525
524 sizeLongHeader = 0#XXXX
526 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
525 self.basicHeaderObj.size = 24 + sizeLongHeader
527 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
526
528
527 self.__writeBasicHeader()
529 self.__writeBasicHeader()
528 self.__wrSystemHeader()
530 self.__wrSystemHeader()
@@ -541,7 +543,7 class JRODataWriter(JRODataIO):
541 if fp == None:
543 if fp == None:
542 fp = self.fp
544 fp = self.fp
543
545
544 self.dataOutObj.basicHeaderObj.write(fp)
546 self.basicHeaderObj.write(fp)
545
547
546
548
547 def __wrSystemHeader(self, fp=None):
549 def __wrSystemHeader(self, fp=None):
@@ -554,7 +556,7 class JRODataWriter(JRODataIO):
554 if fp == None:
556 if fp == None:
555 fp = self.fp
557 fp = self.fp
556
558
557 self.dataOutObj.systemHeaderObj.write(fp)
559 self.systemHeaderObj.write(fp)
558
560
559
561
560 def __wrRadarControllerHeader(self, fp=None):
562 def __wrRadarControllerHeader(self, fp=None):
@@ -567,7 +569,7 class JRODataWriter(JRODataIO):
567 if fp == None:
569 if fp == None:
568 fp = self.fp
570 fp = self.fp
569
571
570 self.dataOutObj.radarControllerHeaderObj.write(fp)
572 self.radarControllerHeaderObj.write(fp)
571
573
572
574
573 def __wrProcessingHeader(self, fp=None):
575 def __wrProcessingHeader(self, fp=None):
@@ -580,7 +582,7 class JRODataWriter(JRODataIO):
580 if fp == None:
582 if fp == None:
581 fp = self.fp
583 fp = self.fp
582
584
583 self.dataOutObj.processingHeaderObj.write(fp)
585 self.processingHeaderObj.write(fp)
584
586
585
587
586 def setNextFile(self):
588 def setNextFile(self):
@@ -648,6 +650,8 class JRODataWriter(JRODataIO):
648 self.setFile = setFile
650 self.setFile = setFile
649 self.flagIsNewFile = 1
651 self.flagIsNewFile = 1
650
652
653 self.getDataHeader()
654
651 print 'Writing the file: %s'%self.filename
655 print 'Writing the file: %s'%self.filename
652
656
653 self.__writeFirstHeader()
657 self.__writeFirstHeader()
@@ -732,18 +736,12 class JRODataWriter(JRODataIO):
732
736
733 self.blocksPerFile = blocksPerFile
737 self.blocksPerFile = blocksPerFile
734
738
739 if not(self.setNextFile()):
740 print "There isn't a next file"
741 return 0
735
742
736
737
738
739 self.getDataHeader()
740
741 self.setBlockDimension()
743 self.setBlockDimension()
742
744
743 if not( self.setNextFile() ):
744 print "There isn't a next file"
745 return 0
746
747 return 1
745 return 1
748
746
749
747
Show file before | Show file after | Hide comments
@@ -341,9 +341,9 class ProcessingHeader(Header):
341 self.deltaHeight = 0
341 self.deltaHeight = 0
342 self.samplesWin = 0
342 self.samplesWin = 0
343 self.spectraComb = 0
343 self.spectraComb = 0
344 self.nCode = 0
344 self.nCode = None
345 self.code = 0
345 self.code = None
346 self.nBaud = 0
346 self.nBaud = None
347 self.shif_fft = False
347 self.shif_fft = False
348 self.flag_dc = False
348 self.flag_dc = False
349 self.flag_cspc = False
349 self.flag_cspc = False
Show file before | Show file after | Hide comments
@@ -203,12 +203,12 class SpectraReader(JRODataReader):
203 self.nRdPairs = 0
203 self.nRdPairs = 0
204 self.rdPairList = []
204 self.rdPairList = []
205
205
206 for i in range( 0, self.processingHeaderObj.totalSpectra*2, 2 ):
206 for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
207 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
207 if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
208 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
208 self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
209 else:
209 else:
210 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
210 self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
211 self.rdPairList.append( (self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]) )
211 self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
212
212
213 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
213 pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
214
214
@@ -369,6 +369,8 class SpectraReader(JRODataReader):
369
369
370 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc #+ self.profileIndex * self.ippSeconds
370 self.dataOutObj.dataUtcTime = self.basicHeaderObj.utc #+ self.profileIndex * self.ippSeconds
371
371
372 self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
373
372 # self.profileIndex += 1
374 # self.profileIndex += 1
373
375
374 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
376 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -385,11 +387,29 class SpectraWriter(JRODataWriter):
385 de los datos siempre se realiza por bloques.
387 de los datos siempre se realiza por bloques.
386 """
388 """
387
389
390 ext = ".pdata"
391
392 optchar = "P"
388
393
389 shape_spc_Buffer = None
394 shape_spc_Buffer = None
395
390 shape_cspc_Buffer = None
396 shape_cspc_Buffer = None
397
391 shape_dc_Buffer = None
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 def __init__(self, dataOutObj=None):
414 def __init__(self, dataOutObj=None):
395 """
415 """
@@ -411,50 +431,55 class SpectraWriter(JRODataWriter):
411 raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
431 raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
412
432
413 self.dataOutObj = dataOutObj
433 self.dataOutObj = dataOutObj
414
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
434
431 self.nWriteBlocks = 0
435 self.nTotalBlocks = 0
432
436
433 self.flagIsNewFile = 1
437 self.nWrChannels = self.dataOutObj.nChannels
434
438
435 self.nTotalBlocks = 0
439 # if len(pairList) > 0:
440 # self.wrPairList = pairList
441 #
442 # self.nWrPairs = len(pairList)
436
443
437 self.flagIsNewBlock = 0
444 self.wrPairList = self.dataOutObj.pairList
438
445
439 self.flagNoMoreFiles = 0
446 self.nWrPairs = self.dataOutObj.nPairs
440
441 self.setFile = None
442
447
443 self.dtype = None
444
448
445 self.path = None
446
449
447 self.noMoreFiles = 0
448
450
449 self.filename = None
451
450
452 # self.data_spc = None
451 self.basicHeaderObj = BasicHeader()
453 # self.data_cspc = None
452
454 # self.data_dc = None
453 self.systemHeaderObj = SystemHeader()
455
454
456 # self.fp = None
455 self.radarControllerHeaderObj = RadarControllerHeader()
457
456
458 # self.flagIsNewFile = 1
457 self.processingHeaderObj = ProcessingHeader()
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 def hasAllDataInBuffer(self):
485 def hasAllDataInBuffer(self):
@@ -571,4 +596,153 class SpectraWriter(JRODataWriter):
571 #print 'Process finished'
596 #print 'Process finished'
572 return 0
597 return 0
573
598
574 return 1 No newline at end of file
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 self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
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 self.profileIndex += 1
310 self.profileIndex += 1
302
311
303 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
312 self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
@@ -338,7 +347,10 class VoltageWriter(JRODataWriter):
338 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
347 raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
339
348
340 self.dataOutObj = dataOutObj
349 self.dataOutObj = dataOutObj
350
351 self.nTotalBlocks = 0
341
352
353 self.profileIndex = 0
342
354
343 def hasAllDataInBuffer(self):
355 def hasAllDataInBuffer(self):
344 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
356 if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
@@ -423,14 +435,17 class VoltageWriter(JRODataWriter):
423 self.profileIndex = 0
435 self.profileIndex = 0
424 self.setNextFile()
436 self.setNextFile()
425
437
438 if self.profileIndex == 0:
439 self.getBasicHeader()
440
426 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
441 self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
427
442
428 self.profileIndex += 1
443 self.profileIndex += 1
429
444
430 if self.hasAllDataInBuffer():
445 if self.hasAllDataInBuffer():
431 #if self.flagIsNewFile:
446 #if self.flagIsNewFile:
432 self.getDataHeader()
433 self.writeNextBlock()
447 self.writeNextBlock()
448 # self.getDataHeader()
434
449
435 if self.flagNoMoreFiles:
450 if self.flagNoMoreFiles:
436 #print 'Process finished'
451 #print 'Process finished'
@@ -438,7 +453,7 class VoltageWriter(JRODataWriter):
438
453
439 return 1
454 return 1
440
455
441 def __getProcessFlag(self):
456 def __getProcessFlags(self):
442
457
443 processFlags = 0
458 processFlags = 0
444
459
@@ -462,7 +477,7 class VoltageWriter(JRODataWriter):
462
477
463
478
464 for index in range(len(dtypeList)):
479 for index in range(len(dtypeList)):
465 if dtypeList == self.dataOutObj.dtype:
480 if self.dataOutObj.dtype == dtypeList[index]:
466 dtypeValue = datatypeValueList[index]
481 dtypeValue = datatypeValueList[index]
467 break
482 break
468
483
@@ -474,12 +489,19 class VoltageWriter(JRODataWriter):
474 if self.dataOutObj.flagDeflipData:
489 if self.dataOutObj.flagDeflipData:
475 processFlags += PROCFLAG.DEFLIP_DATA
490 processFlags += PROCFLAG.DEFLIP_DATA
476
491
492 if self.dataOutObj.code != None:
493 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
494
477 if self.dataOutObj.nCohInt > 1:
495 if self.dataOutObj.nCohInt > 1:
478 processFlags += PROCFLAG.COHERENT_INTEGRATION
496 processFlags += PROCFLAG.COHERENT_INTEGRATION
497
498 return processFlags
479
499
480
500
481 def __getBlockSize(self):
501 def __getBlockSize(self):
482
502 '''
503 Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
504 '''
483
505
484 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
506 dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
485 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
507 dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
@@ -489,15 +511,30 class VoltageWriter(JRODataWriter):
489 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
511 dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
490
512
491 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
513 dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
492 datatypeValueList
514 datatypeValueList = [1,2,4,8,4,8]
493 for index in range(len(dtypeList)):
515 for index in range(len(dtypeList)):
494 if dtypeList == self.dataOutObj.dtype:
516 if self.dataOutObj.dtype == dtypeList[index]:
495 datatypeValue = index
517 datatypeValue = datatypeValueList[index]
496 break
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)
521
522 return blocksize
523
524
525 def getBasicHeader(self):
526 self.basicHeaderObj.size = self.basicHeaderSize #bytes
527 self.basicHeaderObj.version = self.versionFile
528 self.basicHeaderObj.dataBlock = self.nTotalBlocks
499
529
530 utc = numpy.floor(self.dataOutObj.dataUtcTime)
531 milisecond = (self.dataOutObj.dataUtcTime - utc)* 1000.0
500
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
501
538
502 def getDataHeader(self):
539 def getDataHeader(self):
503
540
@@ -513,35 +550,35 class VoltageWriter(JRODataWriter):
513 None
550 None
514 """
551 """
515
552
516 # CALCULAR PARAMETROS
517
518 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
553 self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
519 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
554 self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
520
555
521 self.basicHeaderObj.size = self.basicHeaderSize #bytes
556 self.getBasicHeader()
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
557
530 staticProcessingHeaderSize = 40 # bytes
558 processingHeaderSize = 40 # bytes
531 dynProcessingHeaderSize = 0 # bytes
532
533 self.processingHeaderObj.size = staticProcessingHeaderSize + dynProcessingHeaderSize
534 self.processingHeaderObj.dtype = 0 # Voltage
559 self.processingHeaderObj.dtype = 0 # Voltage
535 # self.processingHeaderObj.dtype = self.dataOutObj.dtype
560 self.processingHeaderObj.blockSize = self.__getBlockSize()
536 self.processingHeaderObj.blockSize = 0 # debe calcular el size en bytes del bloque de datos:
561 self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
537 # usar funcion getBlockSize
538 self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nProfiles
539 self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
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 self.processingHeaderObj.processFlags = self.__getProcessFlags()
564 self.processingHeaderObj.processFlags = self.__getProcessFlags()
542 self.processingHeaderObj.coherentInt = self.dataOutObj.nCohInt
565 self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
543 self.processingHeaderObj.incoherentInt = 1 # Cuando la data de origen sea de tipo Voltage
566 self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
544 self.processingHeaderObj.totalSpectra = 0
567 self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
545
568
546 self.dtype = self.dataOutObj.dtype
569 if self.dataOutObj.code != None:
547 No newline at end of file
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
584 No newline at end of file
Show file before | Show file after | Hide comments
@@ -21,16 +21,24 class TestSChain():
21
21
22 def setValues(self):
22 def setValues(self):
23 self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
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 self.startDate = datetime.date(2011,11,28)
33 self.startDate = datetime.date(2011,11,28)
26 self.endDate = datetime.date(2011,11,30)
34 self.endDate = datetime.date(2011,11,30)
27
35
28 self.startTime = datetime.time(0,0,0)
36 self.startTime = datetime.time(0,0,0)
29 self.endTime = datetime.time(23,59,59)
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 self.profilesPerBlock = 40
40 self.profilesPerBlock = 40
33 self.blocksPerFile = 50
41 self.blocksPerFile = 50
34
42
35 def createObjects(self):
43 def createObjects(self):
36
44
@@ -56,16 +64,17 class TestSChain():
56 while(True):
64 while(True):
57 self.readerObj.getData()
65 self.readerObj.getData()
58
66
59 self.voltObjProc.init()
67 # self.voltObjProc.init()
60
68 #
61 self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
69 # self.voltObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
62
70
63 if self.readerObj.flagNoMoreFiles:
71 if self.readerObj.flagNoMoreFiles:
64 break
72 break
65
73
66 if self.readerObj.flagIsNewBlock:
74 if self.readerObj.flagIsNewBlock:
67 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
75 # print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks, datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
68 datetime.datetime.fromtimestamp(self.readerObj.basicHeaderObj.utc),)
76 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
77 datetime.datetime.utcfromtimestamp(self.readerObj.basicHeaderObj.utc + self.readerObj.basicHeaderObj.miliSecond/1000.0),)
69
78
70
79
71 if __name__ == '__main__':
80 if __name__ == '__main__':
Show file before | Show file after | Hide comments
@@ -5,11 +5,10 import time, datetime
5 path = os.path.split(os.getcwd())[0]
5 path = os.path.split(os.getcwd())[0]
6 sys.path.append(path)
6 sys.path.append(path)
7
7
8 from Data.Voltage import Voltage
8
9 from Data.Spectra import Spectra
9 from Data.Spectra import Spectra
10 from IO.VoltageIO import *
11 from IO.SpectraIO import *
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 self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
25 self.path = "/Users/danielangelsuarezmunoz/Data/EW_Drifts"
27 self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
26 self.path = "/Users/danielangelsuarezmunoz/Data/IMAGING"
28
27
29 self.wrpath = "/Users/jro/Documents/RadarData/wr_data"
30
31 self.startDate = datetime.date(2012,3,1)
28 self.startDate = datetime.date(2012,3,1)
32 self.endDate = datetime.date(2012,3,30)
29 self.endDate = datetime.date(2012,3,30)
33
30
34 self.startTime = datetime.time(0,0,0)
31 self.startTime = datetime.time(0,0,0)
35 self.endTime = datetime.time(14,1,1)
32 self.endTime = datetime.time(14,1,1)
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
36
40
37 def createObjects(self):
41 def createObjects(self):
38
42
39 self.readerObj = SpectraReader()
43 self.readerObj = SpectraReader()
40
44
41 self.voltObj1 = self.readerObj.setup(
45 self.specObj1 = self.readerObj.setup(
42 path = self.path,
46 path = self.path,
43 startDate = self.startDate,
47 startDate = self.startDate,
44 endDate = self.endDate,
48 endDate = self.endDate,
@@ -46,6 +50,10 class TestSChain:
46 endTime = self.endTime,
50 endTime = self.endTime,
47 expLabel = '',
51 expLabel = '',
48 online = 0)
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
@@ -55,13 +63,17 class TestSChain:
55
63
56 while(True):
64 while(True):
57 self.readerObj.getData()
65 self.readerObj.getData()
66
67 self.specObjProc.init()
68
69 self.specObjProc.writeData(self.wrpath,self.profilesPerBlock,self.blocksPerFile)
58
70
59 if self.readerObj.flagNoMoreFiles:
71 if self.readerObj.flagNoMoreFiles:
60 break
72 break
61
73
62 if self.readerObj.flagIsNewBlock:
74 if self.readerObj.flagIsNewBlock:
63 print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
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 if __name__ == '__main__':
79 if __name__ == '__main__':
General Comments 0
You need to be logged in to leave comments. Login now