##// END OF EJS Templates
schain-jc
RSS
SpectraIO.py, modificada por Valentin 27/2/2012 - 12:23
Victor Sarmiento -
r28:df025cb33375
parent child
Show More
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (504 lines changed) Show them Hide them
@@ -1,821 +1,1051
1 '''
1 '''
2 File: SpectraIO.py
2 File: SpectraIO.py
3 Created on 20/02/2012
3 Created on 20/02/2012
4
4
5 @author $Author$
5 @author $Author$
6 @version $Id$
6 @version $Id$
7 '''
7 '''
8
8
9 import os, sys
9 import os, sys
10 import numpy
10 import numpy
11 import glob
11 import glob
12 import fnmatch
12 import fnmatch
13 import time, datetime
13 import time, datetime
14
14
15 path = os.path.split(os.getcwd())[0]
15 path = os.path.split(os.getcwd())[0]
16 sys.path.append(path)
16 sys.path.append(path)
17
17
18 from HeaderIO import *
18 from HeaderIO import *
19 from DataIO import DataReader
19 from DataIO import DataReader
20 from DataIO import DataWriter
20 from DataIO import DataWriter
21
21
22 from Model.Spectra import Spectra
22 from Model.Spectra import Spectra
23
23
24 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
24
25 """
25 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
26 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
26 """
27 o no dentro del rango de fecha especificado.
27 Desc :
28
28 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
29 Inputs:
29 o no dentro del rango de fecha especificado.
30
31 Inputs :
30 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
32 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
31
33
32 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
34 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
33 segundos contados desde 01/01/1970.
35 segundos contados desde 01/01/1970.
36
34 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
37 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
35 segundos contados desde 01/01/1970.
38 segundos contados desde 01/01/1970.
36
39
37 Return:
40 Return :
38 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
41 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
39 fecha especificado, de lo contrario retorna False.
42 fecha especificado, de lo contrario retorna False.
40
43
41 Excepciones:
44 Excepciones :
42 Si el archivo no existe o no puede ser abierto
45 Si el archivo no existe o no puede ser abierto
43 Si la cabecera no puede ser leida.
46 Si la cabecera no puede ser leida.
44
45 """
47 """
46 m_BasicHeader = BasicHeader()
48 m_BasicHeader = BasicHeader()
47
49
48 try:
50 try:
49 fp = open(filename,'rb')
51 fp = open( filename,'rb' ) #lectura binaria
50 except:
52 except:
51 raise IOError, "The file %s can't be opened" %(filename)
53 raise IOError, "The file %s can't be opened" %(filename)
52
54
53 if not(m_BasicHeader.read(fp)):
55 if not(m_BasicHeader.read(fp)):
54 raise IOError, "The file %s has not a valid header" %(filename)
56 raise IOError, "The file %s has not a valid header" %(filename)
55
57
56 fp.close()
58 fp.close()
57
59
58 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
60 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
59 return 0
61 return 0
60
62
61 return 1
63 return 1
62
64
63
65
64 class SpectraReader(DataReader):
66 class SpectraReader( DataReader ):
65 """
67 """
66 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
68 Desc :
67 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
69 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
68 perfiless*alturas*canales) son almacenados en la variable "buffer".
70 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
69
71 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
70 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
72
71 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
73 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
72 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
74 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
73 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
75 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
74
76 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
75 Example:
76
77
78 Example :
77 dpath = "/home/myuser/data"
79 dpath = "/home/myuser/data"
78
80
79 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
81 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
80
82
81 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
83 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
82
84
83 readerObj = SpectraReader()
85 readerObj = SpectraReader()
84
86
85 readerObj.setup(dpath, startTime, endTime)
87 readerObj.setup(dpath, startTime, endTime)
86
88
87 while(True):
89 while(True):
88
90
89 readerObj.getData()
91 readerObj.getData()
90
92
91 print readerObj.m_Spectra.data
93 print readerObj.m_Spectra.data
92
94
93 if readerObj.noMoreFiles:
95 if readerObj.noMoreFiles:
94 break
96 break
95
97
96 """
98 """
97
99
98 #speed of light
100 #speed of light
99 __c = 3E8
101 __c = 3E8
100
102
103
101 def __init__( self, m_Spectra = None ):
104 def __init__( self, m_Spectra = None ):
102 """
105 """
103 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
106 Desc :
104
107 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
105 Input:
108
109 Inputs :
106 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
110 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
107 almacenar un perfil de datos cada vez que se haga un requerimiento
111 almacenar un perfil de datos cada vez que se haga un requerimiento
108 (getData). El perfil sera obtenido a partir del buffer de datos,
112 (getData). El perfil sera obtenido a partir del buffer de datos,
109 si el buffer esta vacio se hara un nuevo proceso de lectura de un
113 si el buffer esta vacio se hara un nuevo proceso de lectura de un
110 bloque de datos.
114 bloque de datos.
111 Si este parametro no es pasado se creara uno internamente.
115 Si este parametro no es pasado se creara uno internamente.
112
116
113 Variables afectadas:
117 Affected :
114 self.m_Spectra
118 self.m_Spectra
115 self.m_BasicHeader
119 self.m_BasicHeader
116 self.m_SystemHeader
120 self.m_SystemHeader
117 self.m_RadarControllerHeader
121 self.m_RadarControllerHeader
118 self.m_ProcessingHeader
122 self.m_ProcessingHeader
119
123
120
124 Return : Nada
121 Return:
122 Void
123
124 """
125 """
125 if m_Spectra == None:
126 if m_Spectra == None:
126 m_Spectra = Spectra()
127 m_Spectra = Spectra()
127
128
128 if not( isinstance(m_Spectra, Spectra) ):
129 if not( isinstance(m_Spectra, Spectra) ):
129 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
130 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
130
131
131 self.m_Spectra = m_Spectra
132 self.m_Spectra = m_Spectra
132
133
133 self.m_BasicHeader = BasicHeader()
134 self.m_BasicHeader = BasicHeader()
134
135
135 self.m_SystemHeader = SystemHeader()
136 self.m_SystemHeader = SystemHeader()
136
137
137 self.m_RadarControllerHeader = RadarControllerHeader()
138 self.m_RadarControllerHeader = RadarControllerHeader()
138
139
139 self.m_ProcessingHeader = ProcessingHeader()
140 self.m_ProcessingHeader = ProcessingHeader()
140
141
141 self.__fp = None
142 self.__fp = None
142
143
143 self.__idFile = None
144 self.__idFile = None
144
145
145 self.__startDateTime = None
146 self.__startDateTime = None
146
147
147 self.__endDateTime = None
148 self.__endDateTime = None
148
149
149 self.__dataType = None
150 self.__dataType = None
150
151
151 self.__fileSizeByHeader = 0
152 self.__fileSizeByHeader = 0
152
153
153 self.__pathList = []
154 self.__pathList = []
154
155
155 self.filenameList = []
156 self.filenameList = []
156
157
157 self.__lastUTTime = 0
158 self.__lastUTTime = 0
158
159
159 self.__maxTimeStep = 30
160 self.__maxTimeStep = 30
160
161
161 self.__flagIsNewFile = 0
162 self.__flagIsNewFile = 0
162
163
163 self.flagResetProcessing = 0
164 self.flagResetProcessing = 0
164
165
165 self.flagIsNewBlock = 0
166 self.flagIsNewBlock = 0
166
167
167 self.noMoreFiles = 0
168 self.noMoreFiles = 0
168
169
169 self.nReadBlocks = 0
170 self.nReadBlocks = 0
170
171
171 self.online = 0
172 self.online = 0
172
173
173 self.firstHeaderSize = 0
174 self.firstHeaderSize = 0
174
175
175 self.basicHeaderSize = 24
176 self.basicHeaderSize = 24
176
177
177 self.filename = None
178 self.filename = None
178
179
179 self.fileSize = None
180 self.fileSize = None
180
181
181 self.__buffer_spc = None
182 self.__buffer_spc = None
182 self.__buffer_cspc = None
183 self.__buffer_cspc = None
183 self.__buffer_dc = None
184 self.__buffer_dc = None
185
186 self.Npair_SelfSpectra = 0
187 self.Npair_CrossSpectra = 0
188
189 self.pts2read_SelfSpectra = 0
190 self.pts2read_CrossSpectra = 0
184
191
185 self.__buffer_id = 0
192 self.__buffer_id = 0
186
193
187 self.__ippSeconds = 0
194 self.__ippSeconds = 0
188
195
189 self.nSelfChannels = 0
196 self.nSelfChannels = 0
190
197
191 self.nCrossPairs = 0
198 self.nCrossPairs = 0
192
199
193 self.nChannels = 0
200 self.nChannels = 0
194
201
202
195 def __rdSystemHeader( self, fp=None ):
203 def __rdSystemHeader( self, fp=None ):
204 """
205 Desc :
206 Lectura del System Header
207
208 Inputs :
209 fp : file pointer
210
211 Affected : Nada
212 self.m_SystemHeader
213
214 Return : Nada
215 """
196 if fp == None:
216 if fp == None:
197 fp = self.__fp
217 fp = self.__fp
198
218
199 self.m_SystemHeader.read( fp )
219 self.m_SystemHeader.read( fp )
220
200
221
201 def __rdRadarControllerHeader( self, fp=None ):
222 def __rdRadarControllerHeader( self, fp=None ):
223 """
224 Desc :
225 Lectura del Radar Controller Header
226
227 Inputs :
228 fp : file pointer
229
230 Affected :
231 self.m_RadarControllerHeader
232
233 Return : Nada
234 """
202 if fp == None:
235 if fp == None:
203 fp = self.__fp
236 fp = self.__fp
204
237
205 self.m_RadarControllerHeader.read(fp)
238 self.m_RadarControllerHeader.read(fp)
239
206
240
207 def __rdProcessingHeader( self,fp=None ):
241 def __rdProcessingHeader( self,fp=None ):
242 """
243 Desc :
244 Lectura del Processing Header
245
246 Inputs :
247 fp : file pointer
248
249 Affected :
250 self.m_ProcessingHeader
251
252 Return : Nada
253 """
208 if fp == None:
254 if fp == None:
209 fp = self.__fp
255 fp = self.__fp
210
256
211 self.m_ProcessingHeader.read(fp)
257 self.m_ProcessingHeader.read(fp)
212
258
259
213 def __rdBasicHeader( self, fp=None ):
260 def __rdBasicHeader( self, fp=None ):
261 """
262 Desc :
263 Lectura del Basic Header
264
265 Inputs :
266 fp : file pointer
267
268 Affected :
269 self.m_BasicHeader
270
271 Return : Nada
272 """
214 if fp == None:
273 if fp == None:
215 fp = self.__fp
274 fp = self.__fp
216
275
217 self.m_BasicHeader.read(fp)
276 self.m_BasicHeader.read(fp)
277
218
278
219 def __readFirstHeader( self ):
279 def __readFirstHeader( self ):
280 """
281 Desc :
282 Lectura del First Header, es decir el Basic Header y el Long Header
283
284 Affected : Nada
285 self.m_BasicHeader
286 self.m_SystemHeader
287 self.m_RadarControllerHeader
288 self.m_ProcessingHeader
289 self.firstHeaderSize
290 self.__heights
291 self.__dataType
292 self.__fileSizeByHeader
293 self.__ippSeconds
294 self.Npair_SelfSpectra
295 self.Npair_CrossSpectra
296 self.pts2read_SelfSpectra
297 self.pts2read_CrossSpectra
298
299 Return : None
300 """
220 self.__rdBasicHeader()
301 self.__rdBasicHeader()
221 self.__rdSystemHeader()
302 self.__rdSystemHeader()
222 self.__rdRadarControllerHeader()
303 self.__rdRadarControllerHeader()
223 self.__rdProcessingHeader()
304 self.__rdProcessingHeader()
224 self.firstHeaderSize = self.m_BasicHeader.size
305 self.firstHeaderSize = self.m_BasicHeader.size
225
306
226 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
307 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
227 if data_type == 0:
308 if data_type == 0:
228 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
309 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
229
310
230 elif data_type == 1:
311 elif data_type == 1:
231 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
312 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
232
313
233 elif data_type == 2:
314 elif data_type == 2:
234 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
315 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
235
316
236 elif data_type == 3:
317 elif data_type == 3:
237 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
318 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
238
319
239 elif data_type == 4:
320 elif data_type == 4:
240 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
321 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
241
322
242 elif data_type == 5:
323 elif data_type == 5:
243 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
324 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
244
325
245 else:
326 else:
246 raise ValueError, 'Data type was not defined'
327 raise ValueError, 'Data type was not defined'
247
328
248 xi = self.m_ProcessingHeader.firstHeight
329 xi = self.m_ProcessingHeader.firstHeight
249 step = self.m_ProcessingHeader.deltaHeight
330 step = self.m_ProcessingHeader.deltaHeight
250 xf = xi + self.m_ProcessingHeader.numHeights*step
331 xf = xi + self.m_ProcessingHeader.numHeights*step
251
332
252 self.__heights = numpy.arange(xi, xf, step)
333 self.__heights = numpy.arange(xi, xf, step)
253 self.__dataType = tmp
334 self.__dataType = tmp
254 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
335 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
255 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
336 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
256
337
338 self.Npair_SelfSpectra = 0
339 self.Npair_CrossSpectra = 0
340
341 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
342 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
343 self.Npair_SelfSpectra = self.Npair_SelfSpectra + 1
344 else:
345 self.Npair_CrossSpectra = self.Npair_CrossSpectra + 1
346
347 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
348 self.pts2read_SelfSpectra = int( pts2read * self.Npair_SelfSpectra )
349 self.pts2read_CrossSpectra = int( pts2read * self.Npair_CrossSpectra )
350
351
257 def __setNextFileOnline( self ):
352 def __setNextFileOnline( self ):
258 return 1
353 return 1
259
354
355
260 def __setNextFileOffline( self ):
356 def __setNextFileOffline( self ):
357 """
358 Desc :
359 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
360
361 Affected :
362 self.__flagIsNewFile
363 self.__idFile
364 self.filename
365 self.fileSize
366 self.__fp
367
368 Return :
369 0 : si un determinado file no puede ser abierto
370 1 : si el file fue abierto con exito
371
372 Excepciones :
373 Si un determinado file no puede ser abierto
374 """
261 idFile = self.__idFile
375 idFile = self.__idFile
262
376
263 while(True):
377 while(True):
264 idFile += 1
378 idFile += 1
265
379
266 if not( idFile < len(self.filenameList) ):
380 if not( idFile < len(self.filenameList) ):
267 self.noMoreFiles = 1
381 self.noMoreFiles = 1
268 return 0
382 return 0
269
383
270 filename = self.filenameList[idFile]
384 filename = self.filenameList[idFile]
271 fileSize = os.path.getsize(filename)
385 fileSize = os.path.getsize(filename)
272
386
273 try:
387 try:
274 fp = open( filename, 'rb' )
388 fp = open( filename, 'rb' )
275 except:
389 except:
276 raise IOError, "The file %s can't be opened" %filename
390 raise IOError, "The file %s can't be opened" %filename
277
391
278 currentSize = fileSize - fp.tell()
392 currentSize = fileSize - fp.tell()
279 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
393 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
280
394
281 if (currentSize < neededSize):
395 if (currentSize < neededSize):
282 print "Skipping the file %s due to it hasn't enough data" %filename
396 print "Skipping the file %s due to it hasn't enough data" %filename
283 continue
397 continue
284
398
285 break
399 break
286
400
287 self.__flagIsNewFile = 1
401 self.__flagIsNewFile = 1
288 self.__idFile = idFile
402 self.__idFile = idFile
289 self.filename = filename
403 self.filename = filename
290 self.fileSize = fileSize
404 self.fileSize = fileSize
291 self.__fp = fp
405 self.__fp = fp
292
406
293 print 'Setting the file: %s'%self.filename
407 print 'Setting the file: %s'%self.filename
294
408
295 return 1
409 return 1
296
410
297 def __setNextFile(self):
411
412 def __setNextFile( self ):
413 """
414 Desc :
415 Determina el siguiente file a leer y si hay uno disponible lee el First Header
416
417 Affected :
418 self.m_BasicHeader
419 self.m_SystemHeader
420 self.m_RadarControllerHeader
421 self.m_ProcessingHeader
422 self.firstHeaderSize
423
424 Return :
425 0 : Si no hay files disponibles
426 1 : Si hay mas files disponibles
427 """
298 if self.online:
428 if self.online:
299 newFile = self.__setNextFileOnline()
429 newFile = self.__setNextFileOnline()
300 else:
430 else:
301 newFile = self.__setNextFileOffline()
431 newFile = self.__setNextFileOffline()
302
432
303 if not(newFile):
433 if not(newFile):
304 return 0
434 return 0
305
435
306 self.__readFirstHeader()
436 self.__readFirstHeader()
307
437
308 return 1
438 return 1
309
439
440
310 def __setNewBlock( self ):
441 def __setNewBlock( self ):
442 """
443 Desc :
444 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
445
446 Affected :
447 self.flagResetProcessing
448 self.ns
449
450 Return :
451 0 : Si el file no tiene un Basic Header que pueda ser leido
452 1 : Si se pudo leer el Basic Header
453 """
311 if self.__fp == None:
454 if self.__fp == None:
312 return 0
455 return 0
313
456
314 if self.__flagIsNewFile:
457 if self.__flagIsNewFile:
315 return 1
458 return 1
316
459
317 currentSize = self.fileSize - self.__fp.tell()
460 currentSize = self.fileSize - self.__fp.tell()
318 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
461 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
319
462
320 #If there is enough data setting new data block
463 #If there is enough data setting new data block
321 if ( currentSize >= neededSize ):
464 if ( currentSize >= neededSize ):
322 self.__rdBasicHeader()
465 self.__rdBasicHeader()
323 return 1
466 return 1
324
467
325 #Setting new file
468 #Setting new file
326 if not( self.__setNextFile() ):
469 if not( self.__setNextFile() ):
327 return 0
470 return 0
328
471
329 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
472 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
330
473
331 self.flagResetProcessing = 0
474 self.flagResetProcessing = 0
332
475
333 if deltaTime > self.__maxTimeStep:
476 if deltaTime > self.__maxTimeStep:
334 self.flagResetProcessing = 1
477 self.flagResetProcessing = 1
335 self.ns = 0
478 self.ns = 0
336
479
337 return 1
480 return 1
338
481
339
482
340
341 def __readBlock(self):
483 def __readBlock(self):
342 """
484 """
343 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
485 Desc :
344 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
486 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
345 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
487 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
346 es seteado a 0
488 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
489 es seteado a 0
347
490
348 Inputs:
349 None
350
351 Return:
491 Return:
352 None
492 None
353
493
354 Variables afectadas:
494 Variables afectadas:
355
356 self.__buffer_id
495 self.__buffer_id
357
358 self.__buffer_sspc
359
360 self.__flagIsNewFile
496 self.__flagIsNewFile
361
362 self.flagIsNewBlock
497 self.flagIsNewBlock
363
364 self.nReadBlocks
498 self.nReadBlocks
365
499 self.__buffer_spc
500 self.__buffer_cspc
501 self.__buffer_dc
366 """
502 """
367 Npair_SelfSpectra = 0
368 Npair_CrossSpectra = 0
369
370 for i in range( 0,self.m_ProcessingHeader.totalSpectra*2,2 ):
371 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
372 Npair_SelfSpectra = Npair_SelfSpectra + 1
373 else:
374 Npair_CrossSpectra = Npair_CrossSpectra + 1
375
376 # self.__buffer_sspc = numpy.concatenate( (data_sspc,data_cspc,data_dcc), axis=0 )
377
378 self.__buffer_id = 0
503 self.__buffer_id = 0
379 self.__flagIsNewFile = 0
504 self.__flagIsNewFile = 0
380 self.flagIsNewBlock = 1
505 self.flagIsNewBlock = 1
381
506
382 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights
507 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.pts2read_SelfSpectra )
383
508 cspc = numpy.fromfile( self.__fp, self.__dataType, self.pts2read_CrossSpectra )
384 spc = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra))
509 dc = numpy.fromfile( self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
385 cspc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra))
386 dc = numpy.fromfile(self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
387
510
388 spc = spc.reshape((Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
511 spc = spc.reshape( (self.Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
389 cspc = cspc.reshape((Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
512
390 dc = dc.reshape((self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights))
513 cspc = cspc.reshape( (self.Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
514 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
391
515
392 if not(self.m_ProcessingHeader.shif_fft):
516 if not( self.m_ProcessingHeader.shif_fft ):
393 spc = numpy.roll(spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
517 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
394 cspc = numpy.roll(cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
518 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
395
519
396 spc = numpy.transpose(spc, (0,2,1))
520 spc = numpy.transpose( spc, (0,2,1) )
397 cspc = numpy.transpose(cspc, (0,2,1))
521 cspc = numpy.transpose( cspc, (0,2,1) )
398 #dc = numpy.transpose(dc, (0,2,1))
522 #dc = numpy.transpose(dc, (0,2,1))
399
523
524 """
400 data_spc = spc
525 data_spc = spc
401 data_cspc = cspc['real'] + cspc['imag']*1j
526 data_cspc = cspc['real'] + cspc['imag']*1j
402 data_dc = dc['real'] + dc['imag']*1j
527 data_dc = dc['real'] + dc['imag']*1j
403
528
404 self.__buffer_spc = data_spc
529 self.__buffer_spc = data_spc
405 self.__buffer_cspc = data_cspc
530 self.__buffer_cspc = data_cspc
406 self.__buffer_dc = data_dc
531 self.__buffer_dc = data_dc
407
532 """
533 self.__buffer_spc = spc
534 self.__buffer_cspc = cspc['real'] + cspc['imag']*1j
535 self.__buffer_dc = dc['real'] + dc['imag']*1j
536
408 self.__flagIsNewFile = 0
537 self.__flagIsNewFile = 0
409
538
410 self.flagIsNewBlock = 1
539 self.flagIsNewBlock = 1
411
540
412 self.nReadBlocks += 1
541 self.nReadBlocks += 1
413
542
414
543
415 def __hasNotDataInBuffer(self):
544 def __hasNotDataInBuffer( self ):
416 return 1
545 return 1
546
417
547
418 def __searchFiles(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
548 def __searchFiles( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
419 """
549 """
420 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
550 Desc :
421 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
551 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
422 correcta la estructura de directorios debe ser la siguiente:
552 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
553 correcta la estructura de directorios debe ser la siguiente:
423
554
424 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
555 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
425
556
426 [yyyy]: anio
557 [yyyy]: anio
427 [ddd] : dia del anio
558 [ddd] : dia del anio
428 [sss] : set del archivo
559 [sss] : set del archivo
429
560
430 Inputs:
561 Inputs:
431 path : Directorio de datos donde se realizara la busqueda. Todos los
562 path : Directorio de datos donde se realizara la busqueda. Todos los
432 ficheros que concidan con el criterio de busqueda seran
563 ficheros que concidan con el criterio de busqueda seran
433 almacenados en una lista y luego retornados.
564 almacenados en una lista y luego retornados.
434 startDateTime : Fecha inicial. Rechaza todos los archivos donde
565 startDateTime : Fecha inicial. Rechaza todos los archivos donde
435 file end time < startDateTime (objeto datetime.datetime)
566 file end time < startDateTime (objeto datetime.datetime)
436
567
437 endDateTime : Fecha final. Rechaza todos los archivos donde
568 endDateTime : Fecha final. Rechaza todos los archivos donde
438 file start time > endDateTime (obejto datetime.datetime)
569 file start time > endDateTime (obejto datetime.datetime)
439
570
440 set : Set del primer archivo a leer. Por defecto None
571 set : Set del primer archivo a leer. Por defecto None
441
572
442 expLabel : Nombre del subdirectorio de datos. Por defecto ""
573 expLabel : Nombre del subdirectorio de datos. Por defecto ""
443
574
444 ext : Extension de los archivos a leer. Por defecto .r
575 ext : Extension de los archivos a leer. Por defecto .r
445
576
446 Return:
577 Return:
447
578
448 (pathList, filenameList)
579 (pathList, filenameList)
449
580
450 pathList : Lista de directorios donde se encontraron archivos dentro
581 pathList : Lista de directorios donde se encontraron archivos dentro
451 de los parametros especificados
582 de los parametros especificados
452 filenameList : Lista de archivos (ruta completa) que coincidieron con los
583 filenameList : Lista de archivos (ruta completa) que coincidieron con los
453 parametros especificados.
584 parametros especificados.
454
585
455 Variables afectadas:
586 Variables afectadas:
456
587
457 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
588 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
458 como fuente para leer los bloque de datos, si se termina
589 como fuente para leer los bloque de datos, si se termina
459 de leer todos los bloques de datos de un determinado
590 de leer todos los bloques de datos de un determinado
460 archivo se pasa al siguiente archivo de la lista.
591 archivo se pasa al siguiente archivo de la lista.
461
462 Excepciones:
463
464 """
592 """
465
593
466 print "Searching files ..."
594 print "Searching files ..."
467
595
468 dirList = []
596 dirList = []
469 for thisPath in os.listdir(path):
597 for thisPath in os.listdir(path):
470 if os.path.isdir(os.path.join(path,thisPath)):
598 if os.path.isdir(os.path.join(path,thisPath)):
471 dirList.append(thisPath)
599 dirList.append(thisPath)
472
600
473 pathList = []
601 pathList = []
474
602
475 thisDateTime = startDateTime
603 thisDateTime = startDateTime
476
604
477 while(thisDateTime <= endDateTime):
605 while(thisDateTime <= endDateTime):
478 year = thisDateTime.timetuple().tm_year
606 year = thisDateTime.timetuple().tm_year
479 doy = thisDateTime.timetuple().tm_yday
607 doy = thisDateTime.timetuple().tm_yday
480
608
481 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
609 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
482 if len(match) == 0:
610 if len(match) == 0:
483 thisDateTime += datetime.timedelta(1)
611 thisDateTime += datetime.timedelta(1)
484 continue
612 continue
485
613
486 pathList.append(os.path.join(path,match[0],expLabel))
614 pathList.append(os.path.join(path,match[0],expLabel))
487 thisDateTime += datetime.timedelta(1)
615 thisDateTime += datetime.timedelta(1)
488
616
489 startUtSeconds = time.mktime(startDateTime.timetuple())
617 startUtSeconds = time.mktime(startDateTime.timetuple())
490 endUtSeconds = time.mktime(endDateTime.timetuple())
618 endUtSeconds = time.mktime(endDateTime.timetuple())
491
619
492 filenameList = []
620 filenameList = []
493 for thisPath in pathList:
621 for thisPath in pathList:
494 fileList = glob.glob1(thisPath, "*%s" %ext)
622 fileList = glob.glob1(thisPath, "*%s" %ext)
495 fileList.sort()
623 fileList.sort()
496 for file in fileList:
624 for file in fileList:
497 filename = os.path.join(thisPath,file)
625 filename = os.path.join(thisPath,file)
498 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
626 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
499 filenameList.append(filename)
627 filenameList.append(filename)
500
628
501 self.filenameList = filenameList
629 self.filenameList = filenameList
502
630
503 return pathList, filenameList
631 return pathList, filenameList
504
632
505
633
506 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
634 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
507 """
635 """
508 setup configura los parametros de lectura de la clase SpectraReader.
636 Desc :
637 setup configura los parametros de lectura de la clase SpectraReader.
509
638
510 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
639 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
511 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
640 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
512 self.filenameList.
641 self.filenameList.
513
642
514 Input:
643 Input:
515 path : Directorios donde se ubican los datos a leer. Dentro de este
644 path : Directorios donde se ubican los datos a leer. Dentro de este
516 directorio deberia de estar subdirectorios de la forma:
645 directorio deberia de estar subdirectorios de la forma:
517
646
518 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
647 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
519
648
520 startDateTime : Fecha inicial. Rechaza todos los archivos donde
649 startDateTime : Fecha inicial. Rechaza todos los archivos donde
521 file end time < startDatetime (objeto datetime.datetime)
650 file end time < startDatetime (objeto datetime.datetime)
522
651
523 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
652 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
524 file end time < startDatetime (objeto datetime.datetime)
653 file end time < startDatetime (objeto datetime.datetime)
525
654
526 set : Set del primer archivo a leer. Por defecto None
655 set : Set del primer archivo a leer. Por defecto None
527
656
528 expLabel : Nombre del subdirectorio de datos. Por defecto ""
657 expLabel : Nombre del subdirectorio de datos. Por defecto ""
529
658
530 ext : Extension de los archivos a leer. Por defecto .r
659 ext : Extension de los archivos a leer. Por defecto .r
531
660
532 online :
661 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
533
662
534 Return:
663 Return:
664 0 : Si no encuentra files que cumplan con las condiciones dadas
665 1 : Si encuentra files que cumplan con las condiciones dadas
535
666
536 Affected:
667 Affected:
537
668 self.startUTCSeconds
538 Excepciones:
669 self.endUTCSeconds
539
670 self.startYear
540 Example:
671 self.endYear
541
672 self.startDoy
673 self.endDoy
674 self.__pathList
675 self.filenameList
676 self.online
542 """
677 """
543 if online == 0:
678 if online == 0:
544 pathList, filenameList = self.__searchFiles(path, startDateTime, endDateTime, set, expLabel, ext)
679 pathList, filenameList = self.__searchFiles( path, startDateTime, endDateTime, set, expLabel, ext )
545
680
546 self.__idFile = -1
681 self.__idFile = -1
547
682
548 if not(self.__setNextFile()):
683 if not(self.__setNextFile()):
549 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
684 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
550 return 0
685 return 0
551
686
552 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
687 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
553 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
688 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
554
689
555 self.startYear = startDateTime.timetuple().tm_year
690 self.startYear = startDateTime.timetuple().tm_year
556 self.endYear = endDateTime.timetuple().tm_year
691 self.endYear = endDateTime.timetuple().tm_year
557
692
558 self.startDoy = startDateTime.timetuple().tm_yday
693 self.startDoy = startDateTime.timetuple().tm_yday
559 self.endDoy = endDateTime.timetuple().tm_yday
694 self.endDoy = endDateTime.timetuple().tm_yday
560 #call fillHeaderValues() - to Data Object
695 #call fillHeaderValues() - to Data Object
561
696
562 self.__pathList = pathList
697 self.__pathList = pathList
563 self.filenameList = filenameList
698 self.filenameList = filenameList
564 self.online = online
699 self.online = online
565
700
566 return 1
701 return 1
702
567
703
568 def readNextBlock(self):
704 def readNextBlock(self):
569 """
705 """
570 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
706 Desc:
571 mas bloques disponibles en el archivo actual salta al siguiente.
707 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
572
708 mas bloques disponibles en el archivo actual salta al siguiente.
709
710 Affected:
711 self.__lastUTTime
712
713 Return: None
573 """
714 """
574
715
575 if not( self.__setNewBlock() ):
716 if not( self.__setNewBlock() ):
576 return 0
717 return 0
577
718
578 self.__readBlock()
719 self.__readBlock()
579
720
580 self.__lastUTTime = self.m_BasicHeader.utc
721 self.__lastUTTime = self.m_BasicHeader.utc
581
722
582 return 1
723 return 1
583
724
584
725
585 def getData(self):
726 def getData(self):
586 """
727 """
587 getData copia el buffer de lectura a la clase "Spectra",
728 Desc:
588 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
729 Copia el buffer de lectura a la clase "Spectra",
589 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
730 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
731 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
590
732
591 Inputs:
592 None
593
594 Return:
733 Return:
595 data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el
734 0 : Si no hay mas archivos disponibles
596 buffer. Si no hay mas archivos a leer retorna None.
735 1 : Si hizo una buena copia del buffer
597
736
598 Variables afectadas:
737 Variables afectadas:
599 self.m_Spectra
738 self.m_Spectra
600 self.__buffer_id
739 self.__buffer_id
601
740 self.flagResetProcessing
602 Excepciones:
741 self.flagIsNewBlock
603
604 """
742 """
605
743
606 self.flagResetProcessing = 0
744 self.flagResetProcessing = 0
607 self.flagIsNewBlock = 0
745 self.flagIsNewBlock = 0
608
746
609 if self.__hasNotDataInBuffer():
747 if self.__hasNotDataInBuffer():
610 self.readNextBlock()
748 self.readNextBlock()
611
749
612 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
750 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
613 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
751 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
614 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
752 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
615 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
753 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
616 self.m_Spectra.heights = self.__heights
754 self.m_Spectra.heights = self.__heights
617 self.m_Spectra.dataType = self.__dataType
755 self.m_Spectra.dataType = self.__dataType
618
756
619 if self.noMoreFiles == 1:
757 if self.noMoreFiles == 1:
620 print 'Process finished'
758 print 'Process finished'
621 return 0
759 return 0
622
760
623 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
761 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
624 #print type(self.__buffer_sspc)
625
762
626 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
763 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
627
764
628 self.m_Spectra.m_BasicHeader.utc = time
765 self.m_Spectra.m_BasicHeader.utc = time
629 self.m_Spectra.data_spc = self.__buffer_spc
766 self.m_Spectra.data_spc = self.__buffer_spc
630 self.m_Spectra.data_cspc = self.__buffer_cspc
767 self.m_Spectra.data_cspc = self.__buffer_cspc
631 self.m_Spectra.data_dc = self.__buffer_dc
768 self.m_Spectra.data_dc = self.__buffer_dc
632
769
633 #call setData - to Data Object
770 #call setData - to Data Object
634
635 return 1
771 return 1
636
772
637
773
638 class SpectraWriter(DataWriter):
774 class SpectraWriter( DataWriter ):
775 """
776 Desc:
777 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
778 de los datos siempre se realiza por bloques.
779 """
639
780
640 def __init__(self):
781 def __init__(self):
782 """
783 Desc :
784 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
785
786 Affected :
787 self.m_Spectra
788 self.m_BasicHeader
789 self.m_SystemHeader
790 self.m_RadarControllerHeader
791 self.m_ProcessingHeader
792
793 Return : None
794 """
641 if m_Spectra == None:
795 if m_Spectra == None:
642 m_Spectra = Spectra()
796 m_Spectra = Spectra()
643
797
644 self.m_Spectra = m_Spectra
798 self.m_Spectra = m_Spectra
645
799
646 self.__fp = None
800 self.__fp = None
647
801
648 self.__blocksCounter = 0
802 self.__blocksCounter = 0
649
803
650 self.__setFile = None
804 self.__setFile = None
651
805
652 self.__flagIsNewFile = 0
806 self.__flagIsNewFile = 0
653
807
654 self.__buffer_sspc = 0
808 self.__buffer_spc = 0
655
809
656 self.__buffer_id = 0
810 self.__buffer_id = 0
657
811
658 self.__dataType = None
812 self.__dataType = None
659
813
660 self.__ext = None
814 self.__ext = None
661
815
662 self.nWriteBlocks = 0
816 self.nWriteBlocks = 0
663
817
664 self.flagIsNewBlock = 0
818 self.flagIsNewBlock = 0
665
819
666 self.noMoreFiles = 0
820 self.noMoreFiles = 0
667
821
668 self.filename = None
822 self.filename = None
669
823
670 self.m_BasicHeader= BasicHeader()
824 self.m_BasicHeader= BasicHeader()
671
825
672 self.m_SystemHeader = SystemHeader()
826 self.m_SystemHeader = SystemHeader()
673
827
674 self.m_RadarControllerHeader = RadarControllerHeader()
828 self.m_RadarControllerHeader = RadarControllerHeader()
675
829
676 self.m_ProcessingHeader = ProcessingHeader()
830 self.m_ProcessingHeader = ProcessingHeader()
831
677
832
678 def __setNextFile(self):
833 def __setNextFile(self):
834 """
835 Desc:
836 Determina el siguiente file que sera escrito
837
838 Affected:
839 self.filename
840 self.__subfolder
841 self.__fp
842 self.__setFile
843 self.__flagIsNewFile
844
845 Return:
846 0 : Si el archivo no puede ser escrito
847 1 : Si el archivo esta listo para ser escrito
848 """
679 setFile = self.__setFile
849 setFile = self.__setFile
680 ext = self.__ext
850 ext = self.__ext
681 path = self.__path
851 path = self.__path
682
852
683 setFile += 1
853 setFile += 1
684
854
685 if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
855 if not( self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile ):
686 self.__fp.close()
856 self.__fp.close()
687 return 0
857 return 0
688
858
689 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
859 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
690 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
860 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
691 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
861 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
692 tmp = os.path.join(path,subfolder)
862 tmp = os.path.join(path,subfolder)
693 if not(os.path.exists(tmp)):
863 if not(os.path.exists(tmp)):
694 os.mkdir(tmp)
864 os.mkdir(tmp)
695
865
696 filename = os.path.join(path,subfolder,file)
866 filename = os.path.join(path,subfolder,file)
697 fp = open(filename,'wb')
867 fp = open(filename,'wb')
698
868
699 #guardando atributos
869 #guardando atributos
700 self.filename = filename
870 self.filename = filename
701 self.__subfolder = subfolder
871 self.__subfolder = subfolder
702 self.__fp = fp
872 self.__fp = fp
703 self.__setFile = setFile
873 self.__setFile = setFile
704 self.__flagIsNewFile = 1
874 self.__flagIsNewFile = 1
705
875
706 print 'Writing the file: %s'%self.filename
876 print 'Writing the file: %s'%self.filename
707
877
708 return 1
878 return 1
709
879
710
711
880
712 def __setNewBlock(self):
881 def __setNewBlock( self ):
882 """
883 Desc:
884 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
885
886 Return:
887 0 : si no pudo escribir nada
888 1 : Si escribio el Basic el First Header
889 """
713 if self.__fp == None:
890 if self.__fp == None:
714 return 0
891 return 0
715
892
716 if self.__flagIsNewFile:
893 if self.__flagIsNewFile:
717 return 1
894 return 1
718
895
719 #Bloques completados?
896 #Bloques completados?
720 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
897 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
721 self.__writeBasicHeader()
898 self.__writeBasicHeader()
722 return 1
899 return 1
723
900
724 if not(self.__setNextFile()):
901 if not(self.__setNextFile()):
725 return 0
902 return 0
726
903
727 self.__writeFirstHeader()
904 self.__writeFirstHeader()
728
905
729 return 1
906 return 1
907
730
908
731 def __writeBlock(self):
909 def __writeBlock(self):
910 """
911 Desc:
912 Escribe el buffer en el file designado
913
914 Return: None
732
915
733 numpy.save(self.__fp,self.__buffer_sspc)
916 Affected:
917 self.__buffer_spc
918 self.__buffer_id
919 self.__flagIsNewFile
920 self.flagIsNewBlock
921 self.nWriteBlocks
922 self.__blocksCounter
923
924 Return: None
925 """
926 numpy.save(self.__fp,self.__buffer_spc)
734
927
735 self.__buffer_sspc = numpy.array([],self.__dataType)
928 self.__buffer_spc = numpy.array([],self.__dataType)
736
929
737 self.__buffer_id = 0
930 self.__buffer_id = 0
738
931
739 self.__flagIsNewFile = 0
932 self.__flagIsNewFile = 0
740
933
741 self.flagIsNewBlock = 1
934 self.flagIsNewBlock = 1
742
935
743 self.nWriteBlocks += 1
936 self.nWriteBlocks += 1
744
937
745 self.__blocksCounter += 1
938 self.__blocksCounter += 1
746
939
940
747 def writeNextBlock(self):
941 def writeNextBlock(self):
942 """
943 Desc:
944 Selecciona el bloque siguiente de datos y los escribe en un file
945
946 Return:
947 0 : Si no hizo pudo escribir el bloque de datos
948 1 : Si no pudo escribir el bloque de datos
949 """
748 if not(self.__setNewBlock()):
950 if not(self.__setNewBlock()):
749 return 0
951 return 0
750
952
751 self.__writeBlock()
953 self.__writeBlock()
752
954
753 return 1
955 return 1
956
754
957
755 def __hasAllDataInBuffer(self):
958 def __hasAllDataInBuffer( self ):
959 """
960 Desc:
961 Determina si se tiene toda la data en el buffer
962
963 Return:
964 0 : Si no tiene toda la data
965 1 : Si tiene toda la data
966 """
756 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
967 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
757 return 1
968 return 1
758
969
759 return 0
970 return 0
971
760
972
761 def putData(self):
973 def putData( self ):
974 """
975 Desc:
976 Setea un bloque de datos y luego los escribe en un file
977
978 Return:
979 None : Si no hay data o no hay mas files que puedan escribirse
980 1 : Si se escribio la data de un bloque en un file
981
982 Affected:
983 self.__buffer_spc
984 self.__buffer_id
985 """
762 self.flagIsNewBlock = 0
986 self.flagIsNewBlock = 0
763
987
764 if self.m_Spectra.noData:
988 if self.m_Spectra.noData:
765 return None
989 return None
766
990
767 shape = self.m_Spectra.data.shape
991 shape = self.m_Spectra.data.shape
768 data = numpy.zeros(shape,self.__dataType)
992 data = numpy.zeros(shape,self.__dataType)
769 data['real'] = self.m_Spectra.data.real
993 data['real'] = self.m_Spectra.data.real
770 data['imag'] = self.m_Spectra.data.imag
994 data['imag'] = self.m_Spectra.data.imag
771 data = data.reshape((-1))
995 data = data.reshape((-1))
772
996
773 self.__buffer_sspc = numpy.hstack((self.__buffer_sspc,data))
997 self.__buffer_spc = numpy.hstack((self.__buffer_spc,data))
774
998
775 self.__buffer_id += 1
999 self.__buffer_id += 1
776
1000
777 if __hasAllDataInBuffer():
1001 if __hasAllDataInBuffer():
778 self.writeNextBlock()
1002 self.writeNextBlock()
779
780
1003
781 if self.noMoreFiles:
1004 if self.noMoreFiles:
782 print 'Process finished'
1005 print 'Process finished'
783 return None
1006 return None
784
1007
785 return 1
1008 return 1
786
1009
787
1010
788 def setup(self,path,set=None,format=None):
1011 def setup( self, set=None, format=None ):
789
1012 """
1013 Desc:
1014 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1015
1016 Inputs:
1017 set : el seteo del file a salvar
1018 format : formato en el cual sera salvado un file
1019 """
790 if set == None:
1020 if set == None:
791 set = -1
1021 set = -1
792 else:
1022 else:
793 set -= 1
1023 set -= 1
794
1024
795 if format == 'hdf5':
1025 if format == 'hdf5':
796 ext = '.hdf5'
1026 ext = '.hdf5'
797 print 'call hdf5 library'
1027 print 'call hdf5 library'
798 return 0
1028 return 0
799
1029
800 if format == 'rawdata':
1030 if format == 'rawdata':
801 ext = '.r'
1031 ext = '.r'
802
1032
803 #call to config_headers
1033 #call to config_headers
804
1034
805 self.__setFile = set
1035 self.__setFile = set
806
1036
807 if not(self.__setNextFile()):
1037 if not( self.__setNextFile() ):
808 print "zzzzzzzzzzzz"
1038 print "zzzzzzzzzzzz"
809 return 0
1039 return 0
810
1040
811 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
1041 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
812
1042
813 self.__buffer_sspc = numpy.array([],self.__dataType)
1043 self.__buffer_spc = numpy.array( [],self.__dataType )
814
1044
815
1045
816
817 def __writeBasicHeader(self):
1046 def __writeBasicHeader(self):
818 pass
1047 pass
819
1048
1049
820 def __writeFirstHeader(self):
1050 def __writeFirstHeader(self):
821 pass
1051 pass
General Comments 0
You need to be logged in to leave comments. Login now