##// END OF EJS Templates
schain
RSS
Miguel Valdez -
r98:e2f0a078c091
parent child
Show More
Show file before | Show file after | Hide comments
@@ -5,26 +5,21 Created on 23/01/2012
5 5 @version $Id$
6 6 '''
7 7
8 from DataIO import DataReader
9 from DataIO import DataWriter
8 from JRODataIO import JRODataIO
10 9
11 class CorrelationReader(DataReader):
10 class CorrelationReader(JRODataIO):
12 11
13 12 def __init__(self):
14 13
15 14 pass
16 15
17 class CorrelationWriter(DataWriter):
16 class CorrelationWriter(JRODataIO):
18 17
19 18 def __init__(self):
20
21 19 pass
22 20
23 def puData(self):
21 def putData(self):
24 22 pass
25 23
26 24 def writeBlock(self):
27 pass
28
29
30 No newline at end of file
25 pass No newline at end of file
Show file before | Show file after | Hide comments
@@ -166,7 +166,7 def getlastFileFromPath(path, ext):
166 166
167 167 return None
168 168
169 class JRODataIO():
169 class JRODataIO:
170 170
171 171 #speed of light
172 172 c = 3E8
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1075 lines changed) Show them Hide them
@@ -1,536 +1,541
1 '''
2 File: SpectraIO.py
3 Created on 20/02/2012
4
5 @author $Author$
6 @version $Id$
7 '''
8
9 import os, sys
10 import numpy
11 import glob
12 import fnmatch
13 import time, datetime
14
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
17
18 from Model.JROHeader import *
19 from Model.Spectra import Spectra
20
21 from JRODataIO import JRODataReader
22 from JRODataIO import JRODataWriter
23 from JRODataIO import isNumber
24
25
26 class SpectraReader( JRODataReader ):
27 """
28 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31
32 paresCanalesIguales * alturas * perfiles (Self Spectra)
33 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
39 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
40
41 Example:
42 dpath = "/home/myuser/data"
43
44 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
45
46 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
47
48 readerObj = SpectraReader()
49
50 readerObj.setup(dpath, startTime, endTime)
51
52 while(True):
53
54 readerObj.getData()
55
56 print readerObj.m_Spectra.data
57
58 if readerObj.flagNoMoreFiles:
59 break
60
61 """
62 m_DataObj = None
63
64 data_spc = None
65 data_cspc = None
66 data_dc = None
67
68 pts2read_SelfSpectra = 0
69 pts2read_CrossSpectra = 0
70 pts2read_DCchannels = 0
71
72 nChannels = 0
73
74 nPairs = 0
75
76 #pairList = None
77
78 channelList = None
79
80 def __init__(self, m_Spectra=None):
81 """
82 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
83
84 Inputs:
85 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
86 almacenar un perfil de datos cada vez que se haga un requerimiento
87 (getData). El perfil sera obtenido a partir del buffer de datos,
88 si el buffer esta vacio se hara un nuevo proceso de lectura de un
89 bloque de datos.
90 Si este parametro no es pasado se creara uno internamente.
91
92 Affected:
93 self.m_DataObj
94
95 Return : None
96 """
97 if m_Spectra == None:
98 m_Spectra = Spectra()
99
100 if not( isinstance(m_Spectra, Spectra) ):
101 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
102
103 self.m_DataObj = m_Spectra
104
105 self.data_spc = None
106 self.data_cspc = None
107 self.data_dc = None
108
109 self.pts2read_SelfSpectra = 0
110 self.pts2read_CrossSpectra = 0
111 self.pts2read_DCs = 0
112
113 self.nChannels = 0
114
115 self.nPairs = 0
116
117 self.ext = ".pdata"
118
119 self.optchar = "P"
120
121 ######################
122
123 self.m_BasicHeader = BasicHeader()
124
125 self.m_SystemHeader = SystemHeader()
126
127 self.m_RadarControllerHeader = RadarControllerHeader()
128
129 self.m_ProcessingHeader = ProcessingHeader()
130
131 self.online = 0
132
133 self.fp = None
134
135 self.fileSizeByHeader = None
136
137 self.filenameList = []
138
139 self.filename = None
140
141 self.fileSize = None
142
143 self.firstHeaderSize = 0
144
145 self.basicHeaderSize = 24
146
147 self.dataType = None
148
149 self.maxTimeStep = 30
150
151 self.flagNoMoreFiles = 0
152
153 self.set = 0
154
155 self.path = None
156
157 self.delay = 3 #seconds
158
159 self.nTries = 3 #quantity tries
160
161 self.nFiles = 3 #number of files for searching
162
163 self.nReadBlocks = 0
164
165 self.flagIsNewFile = 1
166
167 self.ippSeconds = 0
168
169 self.flagResetProcessing = 0
170
171 self.flagIsNewBlock = 0
172
173 self.nTotalBlocks = 0
174
175 self.blocksize = 0
176
177 #pairList = None
178
179 channelList = None
180
181
182 def __hasNotDataInBuffer(self):
183 return 1
184
185
186 def getBlockDimension(self):
187 """
188 Obtiene la cantidad de puntos a leer por cada bloque de datos
189
190 Affected:
191 self.nChannels
192 self.nPairs
193 self.pts2read_SelfSpectra
194 self.pts2read_CrossSpectra
195 self.pts2read_DCchannels
196 self.blocksize
197 self.m_DataObj.nChannels
198 self.m_DataObj.nPairs
199
200 Return:
201 None
202 """
203 self.nChannels = 0
204 self.nPairs = 0
205 self.pairList = []
206
207 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
208 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
209 self.nChannels = self.nChannels + 1 #par de canales iguales
210 else:
211 self.nPairs = self.nPairs + 1 #par de canales diferentes
212 self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
213
214 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
215
216 self.pts2read_SelfSpectra = int( self.nChannels * pts2read )
217 self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
218 self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
219
220 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
221
222 self.channelList = numpy.arange( self.nChannels )
223
224
225 def readBlock(self):
226 """
227 Lee el bloque de datos desde la posicion actual del puntero del archivo
228 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
229 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
230 es seteado a 0
231
232 Return: None
233
234 Variables afectadas:
235 self.datablockIndex
236 self.flagIsNewFile
237 self.flagIsNewBlock
238 self.nTotalBlocks
239 self.data_spc
240 self.data_cspc
241 self.data_dc
242
243 Exceptions:
244 Si un bloque leido no es un bloque valido
245 """
246 blockOk_flag = False
247 fpointer = self.fp.tell()
248
249 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
250 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
251 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
252
253 try:
254 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
255 if self.nPairs != 0:
256 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
257 else:
258 cspc = None
259 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
260 except:
261 print "Data file %s is invalid" % self.filename
262 return 0
263
264 if not( self.m_ProcessingHeader.shif_fft ):
265 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
266 if cspc != None:
267 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
268
269 spc = numpy.transpose( spc, (0,2,1) )
270 if cspc != None: cspc = numpy.transpose( cspc, (0,2,1) )
271
272 self.data_spc = spc
273 if cspc != None:
274 self.data_cspc = cspc['real'] + cspc['imag']*1j
275 else:
276 self.data_cspc = None
277 self.data_dc = dc['real'] + dc['imag']*1j
278
279 self.datablockIndex = 0
280 self.flagIsNewFile = 0
281 self.flagIsNewBlock = 1
282
283 self.nTotalBlocks += 1
284 self.nReadBlocks += 1
285
286 return 1
287
288
289 def getData(self):
290 """
291 Copia el buffer de lectura a la clase "Spectra",
292 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
293 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
294
295 Return:
296 0 : Si no hay mas archivos disponibles
297 1 : Si hizo una buena copia del buffer
298
299 Affected:
300 self.m_DataObj
301 self.datablockIndex
302 self.flagResetProcessing
303 self.flagIsNewBlock
304 """
305
306 if self.flagNoMoreFiles: return 0
307
308 self.flagResetProcessing = 0
309 self.flagIsNewBlock = 0
310
311 if self.__hasNotDataInBuffer():
312
313 if not( self.readNextBlock() ):
314 return 0
315
316 self.updateDataHeader()
317
318 if self.flagNoMoreFiles == 1:
319 print 'Process finished'
320 return 0
321
322 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
323
324 if self.data_dc == None:
325 self.m_DataObj.flagNoData = True
326 return 0
327
328 self.m_DataObj.flagNoData = False
329 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
330
331 self.m_DataObj.data_spc = self.data_spc
332 self.m_DataObj.data_cspc = self.data_cspc
333 self.m_DataObj.data_dc = self.data_dc
334
335 return 1
336
337
338 class SpectraWriter(JRODataWriter):
339
340 """
341 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
342 de los datos siempre se realiza por bloques.
343 """
344
345 m_DataObj = None
346
347 shape_spc_Buffer = None
348 shape_cspc_Buffer = None
349 shape_dc_Buffer = None
350
351 data_spc = None
352 data_cspc = None
353 data_dc = None
354
355
356 def __init__(self, m_Spectra=None):
357 """
358 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
359
360 Affected:
361 self.m_DataObj
362 self.m_BasicHeader
363 self.m_SystemHeader
364 self.m_RadarControllerHeader
365 self.m_ProcessingHeader
366
367 Return: None
368 """
369 if m_Spectra == None:
370 m_Spectra = Spectra()
371
372 if not( isinstance(m_Spectra, Spectra) ):
373 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
374
375 self.m_DataObj = m_Spectra
376
377 self.ext = ".pdata"
378
379 self.optchar = "P"
380
381 self.shape_spc_Buffer = None
382 self.shape_cspc_Buffer = None
383 self.shape_dc_Buffer = None
384
385 self.data_spc = None
386 self.data_cspc = None
387 self.data_dc = None
388
389 ####################################
390
391 self.fp = None
392
393 self.nWriteBlocks = 0
394
395 self.flagIsNewFile = 1
396
397 self.nTotalBlocks = 0
398
399 self.flagIsNewBlock = 0
400
401 self.flagNoMoreFiles = 0
402
403 self.setFile = None
404
405 self.dataType = None
406
407 self.path = None
408
409 self.noMoreFiles = 0
410
411 self.filename = None
412
413 self.m_BasicHeader= BasicHeader()
414
415 self.m_SystemHeader = SystemHeader()
416
417 self.m_RadarControllerHeader = RadarControllerHeader()
418
419 self.m_ProcessingHeader = ProcessingHeader()
420
421
422 def hasAllDataInBuffer(self):
423 return 1
424
425
426 def setBlockDimension(self):
427 """
428 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
429
430 Affected:
431 self.shape_spc_Buffer
432 self.shape_cspc_Buffer
433 self.shape_dc_Buffer
434
435 Return: None
436 """
437 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
438 self.m_ProcessingHeader.numHeights,
439 self.m_ProcessingHeader.profilesPerBlock)
440
441 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
442 self.m_ProcessingHeader.numHeights,
443 self.m_ProcessingHeader.profilesPerBlock)
444
445 self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
446 self.m_ProcessingHeader.numHeights)
447
448
449 def writeBlock(self):
450 """
451 Escribe el buffer en el file designado
452
453 Affected:
454 self.data_spc
455 self.data_cspc
456 self.data_dc
457 self.flagIsNewFile
458 self.flagIsNewBlock
459 self.nTotalBlocks
460 self.nWriteBlocks
461
462 Return: None
463 """
464
465 spc = numpy.transpose( self.data_spc, (0,2,1) )
466 if not( self.m_ProcessingHeader.shif_fft ):
467 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
468 data = spc.reshape((-1))
469 data.tofile(self.fp)
470
471 if self.data_cspc != None:
472 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
473 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
474 if not( self.m_ProcessingHeader.shif_fft ):
475 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
476 data['real'] = cspc.real
477 data['imag'] = cspc.imag
478 data = data.reshape((-1))
479 data.tofile(self.fp)
480
481 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
482 dc = self.data_dc
483 data['real'] = dc.real
484 data['imag'] = dc.imag
485 data = data.reshape((-1))
486 data.tofile(self.fp)
487
488 self.data_spc.fill(0)
489 self.data_dc.fill(0)
490 if self.data_cspc != None:
491 self.data_cspc.fill(0)
492
493 self.flagIsNewFile = 0
494 self.flagIsNewBlock = 1
495 self.nTotalBlocks += 1
496 self.nWriteBlocks += 1
497
498
499 def putData(self):
500 """
501 Setea un bloque de datos y luego los escribe en un file
502
503 Affected:
504 self.data_spc
505 self.data_cspc
506 self.data_dc
507
508 Return:
509 0 : Si no hay data o no hay mas files que puedan escribirse
510 1 : Si se escribio la data de un bloque en un file
511 """
512 self.flagIsNewBlock = 0
513
514 if self.m_DataObj.flagNoData:
515 return 0
516
517 if self.m_DataObj.flagResetProcessing:
518 self.data_spc.fill(0)
519 self.data_cspc.fill(0)
520 self.data_dc.fill(0)
521 self.setNextFile()
522
523 self.data_spc = self.m_DataObj.data_spc
524 self.data_cspc = self.m_DataObj.data_cspc
525 self.data_dc = self.m_DataObj.data_dc
526
527 # #self.m_ProcessingHeader.dataBlocksPerFile)
528 if self.hasAllDataInBuffer():
529 self.getDataHeader()
530 self.writeNextBlock()
531
532 if self.flagNoMoreFiles:
533 #print 'Process finished'
534 return 0
535
1 '''
2 File: SpectraIO.py
3 Created on 20/02/2012
4
5 @author $Author$
6 @version $Id$
7 '''
8
9 import os, sys
10 import numpy
11 import glob
12 import fnmatch
13 import time, datetime
14
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
17
18 from Model.JROHeader import *
19 from Model.Spectra import Spectra
20
21 from JRODataIO import JRODataReader
22 from JRODataIO import JRODataWriter
23 from JRODataIO import isNumber
24
25
26 class SpectraReader(JRODataReader):
27 """
28 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
29 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
30 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
31
32 paresCanalesIguales * alturas * perfiles (Self Spectra)
33 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
34 canales * alturas (DC Channels)
35
36 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
37 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
38 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
39 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
40
41 Example:
42 dpath = "/home/myuser/data"
43
44 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
45
46 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
47
48 readerObj = SpectraReader()
49
50 readerObj.setup(dpath, startTime, endTime)
51
52 while(True):
53
54 readerObj.getData()
55
56 print readerObj.m_Spectra.data
57
58 if readerObj.flagNoMoreFiles:
59 break
60
61 """
62 m_DataObj = None
63
64 data_spc = None
65 data_cspc = None
66 data_dc = None
67
68 pts2read_SelfSpectra = 0
69 pts2read_CrossSpectra = 0
70 pts2read_DCchannels = 0
71
72 nChannels = 0
73
74 nPairs = 0
75
76 #pairList = None
77
78 channelList = None
79
80 def __init__(self, m_Spectra=None):
81 """
82 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
83
84 Inputs:
85 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
86 almacenar un perfil de datos cada vez que se haga un requerimiento
87 (getData). El perfil sera obtenido a partir del buffer de datos,
88 si el buffer esta vacio se hara un nuevo proceso de lectura de un
89 bloque de datos.
90 Si este parametro no es pasado se creara uno internamente.
91
92 Affected:
93 self.m_DataObj
94
95 Return : None
96 """
97 if m_Spectra == None:
98 m_Spectra = Spectra()
99
100 if not( isinstance(m_Spectra, Spectra) ):
101 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
102
103 self.m_DataObj = m_Spectra
104
105 self.data_spc = None
106 self.data_cspc = None
107 self.data_dc = None
108
109 self.pts2read_SelfSpectra = 0
110 self.pts2read_CrossSpectra = 0
111 self.pts2read_DCs = 0
112
113 self.nChannels = 0
114
115 self.nPairs = 0
116
117 self.ext = ".pdata"
118
119 self.optchar = "P"
120
121 ######################
122
123 self.m_BasicHeader = BasicHeader()
124
125 self.m_SystemHeader = SystemHeader()
126
127 self.m_RadarControllerHeader = RadarControllerHeader()
128
129 self.m_ProcessingHeader = ProcessingHeader()
130
131 self.online = 0
132
133 self.fp = None
134
135 self.fileSizeByHeader = None
136
137 self.filenameList = []
138
139 self.filename = None
140
141 self.fileSize = None
142
143 self.firstHeaderSize = 0
144
145 self.basicHeaderSize = 24
146
147 self.dataType = None
148
149 self.maxTimeStep = 30
150
151 self.flagNoMoreFiles = 0
152
153 self.set = 0
154
155 self.path = None
156
157 self.delay = 3 #seconds
158
159 self.nTries = 3 #quantity tries
160
161 self.nFiles = 3 #number of files for searching
162
163 self.nReadBlocks = 0
164
165 self.flagIsNewFile = 1
166
167 self.ippSeconds = 0
168
169 self.flagResetProcessing = 0
170
171 self.flagIsNewBlock = 0
172
173 self.nTotalBlocks = 0
174
175 self.blocksize = 0
176
177 #pairList = None
178
179 channelList = None
180
181
182 def __hasNotDataInBuffer(self):
183 return 1
184
185
186 def getBlockDimension(self):
187 """
188 Obtiene la cantidad de puntos a leer por cada bloque de datos
189
190 Affected:
191 self.nChannels
192 self.nPairs
193 self.pts2read_SelfSpectra
194 self.pts2read_CrossSpectra
195 self.pts2read_DCchannels
196 self.blocksize
197 self.m_DataObj.nChannels
198 self.m_DataObj.nPairs
199
200 Return:
201 None
202 """
203 self.nChannels = 0
204 self.nPairs = 0
205 self.pairList = []
206
207 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
208 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
209 self.nChannels = self.nChannels + 1 #par de canales iguales
210 else:
211 self.nPairs = self.nPairs + 1 #par de canales diferentes
212 self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
213
214 pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
215
216 self.pts2read_SelfSpectra = int( self.nChannels * pts2read )
217 self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
218 self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
219
220 self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
221
222 self.channelList = numpy.arange( self.nChannels )
223
224
225 def readBlock(self):
226 """
227 Lee el bloque de datos desde la posicion actual del puntero del archivo
228 (self.fp) y actualiza todos los parametros relacionados al bloque de datos
229 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
230 es seteado a 0
231
232 Return: None
233
234 Variables afectadas:
235 self.datablockIndex
236 self.flagIsNewFile
237 self.flagIsNewBlock
238 self.nTotalBlocks
239 self.data_spc
240 self.data_cspc
241 self.data_dc
242
243 Exceptions:
244 Si un bloque leido no es un bloque valido
245 """
246 blockOk_flag = False
247 fpointer = self.fp.tell()
248
249 spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
250 cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
251 dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
252
253 try:
254 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
255 if self.nPairs != 0:
256 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
257 else:
258 cspc = None
259 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
260 except:
261 print "Data file %s is invalid" % self.filename
262 return 0
263
264 if not( self.m_ProcessingHeader.shif_fft ):
265 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
266
267 if cspc != None:
268 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
269
270 spc = numpy.transpose( spc, (0,2,1) )
271
272 if cspc != None:
273 cspc = numpy.transpose( cspc, (0,2,1) )
274
275
276 if cspc != None:
277 self.data_cspc = cspc['real'] + cspc['imag']*1j
278 else:
279 self.data_cspc = None
280
281 self.data_spc = spc
282 self.data_dc = dc['real'] + dc['imag']*1j
283
284 self.datablockIndex = 0
285 self.flagIsNewFile = 0
286 self.flagIsNewBlock = 1
287
288 self.nTotalBlocks += 1
289 self.nReadBlocks += 1
290
291 return 1
292
293
294 def getData(self):
295 """
296 Copia el buffer de lectura a la clase "Spectra",
297 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
298 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
299
300 Return:
301 0 : Si no hay mas archivos disponibles
302 1 : Si hizo una buena copia del buffer
303
304 Affected:
305 self.m_DataObj
306 self.datablockIndex
307 self.flagResetProcessing
308 self.flagIsNewBlock
309 """
310
311 if self.flagNoMoreFiles: return 0
312
313 self.flagResetProcessing = 0
314 self.flagIsNewBlock = 0
315
316 if self.__hasNotDataInBuffer():
317
318 if not( self.readNextBlock() ):
319 return 0
320
321 self.updateDataHeader()
322
323 if self.flagNoMoreFiles == 1:
324 print 'Process finished'
325 return 0
326
327 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
328
329 if self.data_dc == None:
330 self.m_DataObj.flagNoData = True
331 return 0
332
333 self.m_DataObj.flagNoData = False
334 self.m_DataObj.flagResetProcessing = self.flagResetProcessing
335
336 self.m_DataObj.data_spc = self.data_spc
337 self.m_DataObj.data_cspc = self.data_cspc
338 self.m_DataObj.data_dc = self.data_dc
339
340 return 1
341
342
343 class SpectraWriter(JRODataWriter):
344
345 """
346 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
347 de los datos siempre se realiza por bloques.
348 """
349
350 m_DataObj = None
351
352 shape_spc_Buffer = None
353 shape_cspc_Buffer = None
354 shape_dc_Buffer = None
355
356 data_spc = None
357 data_cspc = None
358 data_dc = None
359
360
361 def __init__(self, m_Spectra=None):
362 """
363 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
364
365 Affected:
366 self.m_DataObj
367 self.m_BasicHeader
368 self.m_SystemHeader
369 self.m_RadarControllerHeader
370 self.m_ProcessingHeader
371
372 Return: None
373 """
374 if m_Spectra == None:
375 m_Spectra = Spectra()
376
377 if not( isinstance(m_Spectra, Spectra) ):
378 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
379
380 self.m_DataObj = m_Spectra
381
382 self.ext = ".pdata"
383
384 self.optchar = "P"
385
386 self.shape_spc_Buffer = None
387 self.shape_cspc_Buffer = None
388 self.shape_dc_Buffer = None
389
390 self.data_spc = None
391 self.data_cspc = None
392 self.data_dc = None
393
394 ####################################
395
396 self.fp = None
397
398 self.nWriteBlocks = 0
399
400 self.flagIsNewFile = 1
401
402 self.nTotalBlocks = 0
403
404 self.flagIsNewBlock = 0
405
406 self.flagNoMoreFiles = 0
407
408 self.setFile = None
409
410 self.dataType = None
411
412 self.path = None
413
414 self.noMoreFiles = 0
415
416 self.filename = None
417
418 self.m_BasicHeader= BasicHeader()
419
420 self.m_SystemHeader = SystemHeader()
421
422 self.m_RadarControllerHeader = RadarControllerHeader()
423
424 self.m_ProcessingHeader = ProcessingHeader()
425
426
427 def hasAllDataInBuffer(self):
428 return 1
429
430
431 def setBlockDimension(self):
432 """
433 Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
434
435 Affected:
436 self.shape_spc_Buffer
437 self.shape_cspc_Buffer
438 self.shape_dc_Buffer
439
440 Return: None
441 """
442 self.shape_spc_Buffer = (self.m_DataObj.nChannels,
443 self.m_ProcessingHeader.numHeights,
444 self.m_ProcessingHeader.profilesPerBlock)
445
446 self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
447 self.m_ProcessingHeader.numHeights,
448 self.m_ProcessingHeader.profilesPerBlock)
449
450 self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
451 self.m_ProcessingHeader.numHeights)
452
453
454 def writeBlock(self):
455 """
456 Escribe el buffer en el file designado
457
458 Affected:
459 self.data_spc
460 self.data_cspc
461 self.data_dc
462 self.flagIsNewFile
463 self.flagIsNewBlock
464 self.nTotalBlocks
465 self.nWriteBlocks
466
467 Return: None
468 """
469
470 spc = numpy.transpose( self.data_spc, (0,2,1) )
471 if not( self.m_ProcessingHeader.shif_fft ):
472 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
473 data = spc.reshape((-1))
474 data.tofile(self.fp)
475
476 if self.data_cspc != None:
477 data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
478 cspc = numpy.transpose( self.data_cspc, (0,2,1) )
479 if not( self.m_ProcessingHeader.shif_fft ):
480 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
481 data['real'] = cspc.real
482 data['imag'] = cspc.imag
483 data = data.reshape((-1))
484 data.tofile(self.fp)
485
486 data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
487 dc = self.data_dc
488 data['real'] = dc.real
489 data['imag'] = dc.imag
490 data = data.reshape((-1))
491 data.tofile(self.fp)
492
493 self.data_spc.fill(0)
494 self.data_dc.fill(0)
495 if self.data_cspc != None:
496 self.data_cspc.fill(0)
497
498 self.flagIsNewFile = 0
499 self.flagIsNewBlock = 1
500 self.nTotalBlocks += 1
501 self.nWriteBlocks += 1
502
503
504 def putData(self):
505 """
506 Setea un bloque de datos y luego los escribe en un file
507
508 Affected:
509 self.data_spc
510 self.data_cspc
511 self.data_dc
512
513 Return:
514 0 : Si no hay data o no hay mas files que puedan escribirse
515 1 : Si se escribio la data de un bloque en un file
516 """
517 self.flagIsNewBlock = 0
518
519 if self.m_DataObj.flagNoData:
520 return 0
521
522 if self.m_DataObj.flagResetProcessing:
523 self.data_spc.fill(0)
524 self.data_cspc.fill(0)
525 self.data_dc.fill(0)
526 self.setNextFile()
527
528 self.data_spc = self.m_DataObj.data_spc
529 self.data_cspc = self.m_DataObj.data_cspc
530 self.data_dc = self.m_DataObj.data_dc
531
532 # #self.m_ProcessingHeader.dataBlocksPerFile)
533 if self.hasAllDataInBuffer():
534 self.getDataHeader()
535 self.writeNextBlock()
536
537 if self.flagNoMoreFiles:
538 #print 'Process finished'
539 return 0
540
536 541 return 1 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,57 +1,57
1 '''
2 Created on 23/01/2012
3
4 @author $Author$
5 @version $Id$
6 '''
7 import os
8 import sys
9 import datetime
10 import time
11
12 class TestIO():
13
14 def __init__(self):
15 self.setValues()
16 self.createVoltageObjects()
17 self.testReadVoltage()
18 pass
19
20 def setValues(self):
21
22
23 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
24 self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
25 self.endDateTime = datetime.datetime(2007,5,1,18,15,0)
26
27 def createVoltageObjects(self):
28 path = os.path.split(os.getcwd())[0]
29 sys.path.append(path)
30
31 from IO.VoltageIO import VoltageReader
32 from IO.VoltageIO import VoltageWriter
33 from Model.Voltage import Voltage
34
35 self.voltageModelObj = Voltage()
36 self.voltageReaderObj = VoltageReader(self.voltageModelObj)
37 self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
38
39 # self.voltageWriterObj = VoltageWriter(self.voltageModelObj)
40 # self.voltageWriterObj.setup('/Users/danielangelsuarezmunoz/Documents/Projects/testWR')
41
42
43 def testReadVoltage(self):
44 while(not(self.voltageReaderObj.noMoreFiles)):
45
46 self.voltageReaderObj.getData()
47 if self.voltageReaderObj.flagResetProcessing:
48 print 'jump'
49
50 if self.voltageReaderObj.flagIsNewBlock:
51 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nTotalBlocks,
52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53
54 # self.voltageWriterObj.putData()
55
56 if __name__ == '__main__':
1 '''
2 Created on 23/01/2012
3
4 @author $Author$
5 @version $Id$
6 '''
7 import os
8 import sys
9 import datetime
10 import time
11
12 class TestIO:
13
14 def __init__(self):
15 self.setValues()
16 self.createVoltageObjects()
17 self.testReadVoltage()
18 pass
19
20 def setValues(self):
21
22
23 self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
24 self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
25 self.endDateTime = datetime.datetime(2007,5,1,18,15,0)
26
27 def createVoltageObjects(self):
28 path = os.path.split(os.getcwd())[0]
29 sys.path.append(path)
30
31 from IO.VoltageIO import VoltageReader
32 from IO.VoltageIO import VoltageWriter
33 from Model.Voltage import Voltage
34
35 self.voltageModelObj = Voltage()
36 self.voltageReaderObj = VoltageReader(self.voltageModelObj)
37 self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
38
39 # self.voltageWriterObj = VoltageWriter(self.voltageModelObj)
40 # self.voltageWriterObj.setup('/Users/danielangelsuarezmunoz/Documents/Projects/testWR')
41
42
43 def testReadVoltage(self):
44 while(not(self.voltageReaderObj.noMoreFiles)):
45
46 self.voltageReaderObj.getData()
47 if self.voltageReaderObj.flagResetProcessing:
48 print 'jump'
49
50 if self.voltageReaderObj.flagIsNewBlock:
51 print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nTotalBlocks,
52 datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53
54 # self.voltageWriterObj.putData()
55
56 if __name__ == '__main__':
57 57 TestIO() No newline at end of file
Show file before | Show file after | Hide comments
@@ -297,7 +297,7 class VoltageReader(JRODataReader):
297 297 return 1 #self.m_DataObj.data
298 298
299 299
300 class VoltageWriter( JRODataWriter ):
300 class VoltageWriter(JRODataWriter):
301 301 """
302 302 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
303 303 de los datos siempre se realiza por bloques.
General Comments 0
You need to be logged in to leave comments. Login now