##// END OF EJS Templates
schain
RSS
Victor Sarmiento -
r30:b60100ccfe27
parent child
Show More
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1123 lines changed) Show them Hide them
@@ -1,925 +1,1642
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 isNumber( str ):
25 """
26 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
27
28 Excepciones:
29 Si un determinado string no puede ser convertido a numero
30 Input:
31 str, string al cual se le analiza para determinar si convertible a un numero o no
32
33 Return:
34 True : si el string es uno numerico
35 False : no es un string numerico
36 """
37 try:
38 float( str )
39 return True
40 except:
41 return False
42
43
44
24 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
45 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
25 """
46 """
26 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
47 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
27 o no dentro del rango de fecha especificado.
48 o no dentro del rango de fecha especificado.
28
49
29 Inputs:
50 Inputs:
30 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
51 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
31
52
32 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
53 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
33 segundos contados desde 01/01/1970.
54 segundos contados desde 01/01/1970.
55
34 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
56 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
35 segundos contados desde 01/01/1970.
57 segundos contados desde 01/01/1970.
36
58
37 Return:
59 Return:
38 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
60 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
39 fecha especificado, de lo contrario retorna False.
61 fecha especificado, de lo contrario retorna False.
40
62
41 Excepciones:
63 Excepciones:
42 Si el archivo no existe o no puede ser abierto
64 Si el archivo no existe o no puede ser abierto
43 Si la cabecera no puede ser leida.
65 Si la cabecera no puede ser leida.
44
45 """
66 """
46 m_BasicHeader = BasicHeader()
67 m_BasicHeader = BasicHeader()
47
68
48 try:
69 try:
49 fp = open(filename,'rb')
70 fp = open( filename,'rb' ) #lectura binaria
50 except:
71 except:
51 raise IOError, "The file %s can't be opened" %(filename)
72 raise IOError, "The file %s can't be opened" %(filename)
52
73
53 if not(m_BasicHeader.read(fp)):
74 if not(m_BasicHeader.read(fp)):
54 raise IOError, "The file %s has not a valid header" %(filename)
75 raise IOError, "The file %s has not a valid header" %(filename)
55
76
56 fp.close()
77 fp.close()
57
78
58 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
79 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
59 return 0
80 return 0
60
81
61 return 1
82 return 1
62
83
63
84
64 class SpectraReader(DataReader):
85 class SpectraReader( DataReader ):
65 """
86 """
66 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
87 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
67 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
88 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
68 perfiless*alturas*canales) son almacenados en la variable "buffer".
89 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
69
90
70 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
91 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
71 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
92 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
72 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
93 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
73 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
94 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
74
95
75 Example:
96 Example:
76
77 dpath = "/home/myuser/data"
97 dpath = "/home/myuser/data"
78
98
79 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
99 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
80
100
81 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
101 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
82
102
83 readerObj = SpectraReader()
103 readerObj = SpectraReader()
84
104
85 readerObj.setup(dpath, startTime, endTime)
105 readerObj.setup(dpath, startTime, endTime)
86
106
87 while(True):
107 while(True):
88
108
89 readerObj.getData()
109 readerObj.getData()
90
110
91 print readerObj.m_Spectra.data
111 print readerObj.m_Spectra.data
92
112
93 if readerObj.noMoreFiles:
113 if readerObj.noMoreFiles:
94 break
114 break
95
115
96 """
116 """
97
117
98 #speed of light
118 #speed of light
99 __c = 3E8
119 __c = 3E8
100
120
121
101 def __init__( self, m_Spectra = None ):
122 def __init__( self, m_Spectra = None ):
102 """
123 """
103 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
124 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
104
125
105 Input:
126 Inputs:
106 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
127 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
128 almacenar un perfil de datos cada vez que se haga un requerimiento
108 (getData). El perfil sera obtenido a partir del buffer de datos,
129 (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
130 si el buffer esta vacio se hara un nuevo proceso de lectura de un
110 bloque de datos.
131 bloque de datos.
111 Si este parametro no es pasado se creara uno internamente.
132 Si este parametro no es pasado se creara uno internamente.
112
133
113 Variables afectadas:
134 Affected:
114 self.m_Spectra
135 self.m_Spectra
115 self.m_BasicHeader
136 self.m_BasicHeader
116 self.m_SystemHeader
137 self.m_SystemHeader
117 self.m_RadarControllerHeader
138 self.m_RadarControllerHeader
118 self.m_ProcessingHeader
139 self.m_ProcessingHeader
119
140
120
141 Return : None
121 Return:
122 Void
123
124 """
142 """
125 if m_Spectra == None:
143 if m_Spectra == None:
126 m_Spectra = Spectra()
144 m_Spectra = Spectra()
127
145
128 if not( isinstance(m_Spectra, Spectra) ):
146 if not( isinstance(m_Spectra, Spectra) ):
129 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
147 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
130
148
131 self.m_Spectra = m_Spectra
149 self.m_Spectra = m_Spectra
132
150
133 self.m_BasicHeader = BasicHeader()
151 self.m_BasicHeader = BasicHeader()
134
152
135 self.m_SystemHeader = SystemHeader()
153 self.m_SystemHeader = SystemHeader()
136
154
137 self.m_RadarControllerHeader = RadarControllerHeader()
155 self.m_RadarControllerHeader = RadarControllerHeader()
138
156
139 self.m_ProcessingHeader = ProcessingHeader()
157 self.m_ProcessingHeader = ProcessingHeader()
140
158
141 self.__fp = None
159 self.__fp = None
142
160
143 self.__idFile = None
161 self.__idFile = None
144
162
145 self.__startDateTime = None
163 self.__startDateTime = None
146
164
147 self.__endDateTime = None
165 self.__endDateTime = None
148
166
149 self.__dataType = None
167 self.__dataType = None
150
168
151 self.__fileSizeByHeader = 0
169 self.__fileSizeByHeader = 0
152
170
153 self.__pathList = []
171 self.__pathList = []
154
172
155 self.filenameList = []
173 self.filenameList = []
156
174
157 self.__lastUTTime = 0
175 self.__lastUTTime = 0
158
176
159 self.__maxTimeStep = 30
177 self.__maxTimeStep = 30
160
178
161 self.__flagIsNewFile = 0
179 self.__flagIsNewFile = 0
162
180
163 self.flagResetProcessing = 0
181 self.flagResetProcessing = 0
164
182
165 self.flagIsNewBlock = 0
183 self.flagIsNewBlock = 0
166
184
167 self.noMoreFiles = 0
185 self.noMoreFiles = 0
168
186
169 self.nReadBlocks = 0
187 self.nReadBlocks = 0
170
188
171 self.online = 0
189 self.online = 0
172
190
173 self.firstHeaderSize = 0
191 self.firstHeaderSize = 0
174
192
175 self.basicHeaderSize = 24
193 self.basicHeaderSize = 24
176
194
177 self.filename = None
195 self.filename = None
178
196
179 self.fileSize = None
197 self.fileSize = None
180
198
181 self.__buffer_spc = None
199 self.__data_spc = None
182 self.__buffer_cspc = None
200 self.__data_cspc = None
183 self.__buffer_dc = None
201 self.__data_dc = None
184
202
185 self.__buffer_id = 0
203 self.nChannels = 0
204 self.nPairs = 0
205
206 self.__pts2read_SelfSpectra = 0
207 self.__pts2read_CrossSpectra = 0
208 self.__pts2read_DCchannels = 0
209 self.__blocksize = 0
210
211 self.__datablockIndex = 0
186
212
187 self.__ippSeconds = 0
213 self.__ippSeconds = 0
188
214
189 self.nSelfChannels = 0
215 self.nSelfChannels = 0
190
216
191 self.nCrossPairs = 0
217 self.nCrossPairs = 0
192
218
193 self.nChannels = 0
219 self.__delay = 7 #seconds
194
220 self.__nTries = 3 #quantity tries
195 self.__path = None
221 self.__nFiles = 3 #number of files for searching
196 self.__startDateTime = None
222 self.__year = 0
197 self.__endDateTime = None
223 self.__doy = 0
198 self.__expLabel = None
224 self.__set = 0
199 self.__set = None
200 self.__ext = None
225 self.__ext = None
226 self.__path = None
227 self.datablock_id = 9999
228
201
229
202 def __rdSystemHeader( self, fp=None ):
230 def __rdSystemHeader( self, fp=None ):
231 """
232 Lectura del System Header
233
234 Inputs:
235 fp : file pointer
236
237 Affected:
238 self.m_SystemHeader
239
240 Return: None
241 """
203 if fp == None:
242 if fp == None:
204 fp = self.__fp
243 fp = self.__fp
205
244
206 self.m_SystemHeader.read( fp )
245 self.m_SystemHeader.read( fp )
207
246
247
248
208 def __rdRadarControllerHeader( self, fp=None ):
249 def __rdRadarControllerHeader( self, fp=None ):
250 """
251 Lectura del Radar Controller Header
252
253 Inputs:
254 fp : file pointer
255
256 Affected:
257 self.m_RadarControllerHeader
258
259 Return: None
260 """
209 if fp == None:
261 if fp == None:
210 fp = self.__fp
262 fp = self.__fp
211
263
212 self.m_RadarControllerHeader.read(fp)
264 self.m_RadarControllerHeader.read(fp)
213
265
266
214 def __rdProcessingHeader( self,fp=None ):
267 def __rdProcessingHeader( self,fp=None ):
268 """
269 Lectura del Processing Header
270
271 Inputs:
272 fp : file pointer
273
274 Affected:
275 self.m_ProcessingHeader
276
277 Return: None
278 """
215 if fp == None:
279 if fp == None:
216 fp = self.__fp
280 fp = self.__fp
217
281
218 self.m_ProcessingHeader.read(fp)
282 self.m_ProcessingHeader.read(fp)
219
283
284
220 def __rdBasicHeader( self, fp=None ):
285 def __rdBasicHeader( self, fp=None ):
286 """
287 Lectura del Basic Header
288
289 Inputs:
290 fp : file pointer
291
292 Affected:
293 self.m_BasicHeader
294
295 Return: None
296 """
221 if fp == None:
297 if fp == None:
222 fp = self.__fp
298 fp = self.__fp
223
299
224 self.m_BasicHeader.read(fp)
300 self.m_BasicHeader.read(fp)
225
301
302
226 def __readFirstHeader( self ):
303 def __readFirstHeader( self ):
304 """
305 Lectura del First Header, es decir el Basic Header y el Long Header
306
307 Affected:
308 self.m_BasicHeader
309 self.m_SystemHeader
310 self.m_RadarControllerHeader
311 self.m_ProcessingHeader
312 self.firstHeaderSize
313 self.__heights
314 self.__dataType
315 self.__fileSizeByHeader
316 self.__ippSeconds
317 self.nChannels
318 self.nPairs
319 self.__pts2read_SelfSpectra
320 self.__pts2read_CrossSpectra
321
322 Return: None
323 """
227 self.__rdBasicHeader()
324 self.__rdBasicHeader()
228 self.__rdSystemHeader()
325 self.__rdSystemHeader()
229 self.__rdRadarControllerHeader()
326 self.__rdRadarControllerHeader()
230 self.__rdProcessingHeader()
327 self.__rdProcessingHeader()
231 self.firstHeaderSize = self.m_BasicHeader.size
328 self.firstHeaderSize = self.m_BasicHeader.size
232
329
233 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
330 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
234 if data_type == 0:
331 if data_type == 0:
235 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
332 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
236
333
237 elif data_type == 1:
334 elif data_type == 1:
238 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
335 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
239
336
240 elif data_type == 2:
337 elif data_type == 2:
241 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
338 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
242
339
243 elif data_type == 3:
340 elif data_type == 3:
244 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
341 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
245
342
246 elif data_type == 4:
343 elif data_type == 4:
247 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
344 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
248
345
249 elif data_type == 5:
346 elif data_type == 5:
250 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
347 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
251
348
252 else:
349 else:
253 raise ValueError, 'Data type was not defined'
350 raise ValueError, 'Data type was not defined'
254
351
255 xi = self.m_ProcessingHeader.firstHeight
352 xi = self.m_ProcessingHeader.firstHeight
256 step = self.m_ProcessingHeader.deltaHeight
353 step = self.m_ProcessingHeader.deltaHeight
257 xf = xi + self.m_ProcessingHeader.numHeights*step
354 xf = xi + self.m_ProcessingHeader.numHeights*step
258
355
259 self.__heights = numpy.arange(xi, xf, step)
356 self.__heights = numpy.arange(xi, xf, step)
357
260 self.__dataType = tmp
358 self.__dataType = tmp
261 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
359 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
262 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
360 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.__c
263
361
264 def __setNextFileOnline(self, delay = 60 ):
362 self.nChannels = 0
363 self.nPairs = 0
364
365 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
366 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
367 self.nChannels = self.nChannels + 1
368 else:
369 self.nPairs = self.nPairs + 1
370
371 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
372 self.__pts2read_SelfSpectra = int( pts2read * self.nChannels )
373 self.__pts2read_CrossSpectra = int( pts2read * self.nPairs )
374 self.__pts2read_DCchannels = int( self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels )
375
376 self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels
377
378 self.m_Spectra.nChannels = self.nChannels
379 self.m_Spectra.nPairs = self.nPairs
380
381
382 def __checkForRealPath( self ):
383 """
384 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
385 el path exacto de un determinado file.
386
387 Example :
388 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
389
390 Entonces la funcion prueba con las siguientes combinaciones
391 ../RAWDATA/d2009307/p2009307367
392 ../RAWDATA/d2009307/P2009307367
393 ../RAWDATA/D2009307/p2009307367
394 ../RAWDATA/D2009307/P2009307367
395 siendo para este caso, la ultima combinacion de letras, identica al file buscado
396
397 Return:
398 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
399 caso contrario devuelve None
265 """
400 """
401 filepath = None
402 find_flag = False
403 filename = None
404
405 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
406 for fil in "pP": #barrido por las dos combinaciones posibles de "D"
407 doypath = "%s%04d%03d" % ( dir, self.__year, self.__doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
408 filename = "%s%04d%03d%03d%s" % ( fil, self.__year, self.__doy, self.__set, self.__ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
409 filepath = os.path.join( self.__path, doypath, filename ) #formo el path completo
410 if os.path.exists( filepath ): #verifico que exista
411 find_flag = True
412 break
413 if find_flag:
414 break
266
415
416 if not(find_flag):
417 return None, filename
267
418
268 return:
419 return filepath, filename
269 bool
270
420
421
422 def __setNextFileOnline( self ):
271 """
423 """
272 nFiles = 3
424 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
273 nTries = 3
425 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
426 siguientes.
427
428 Affected:
429 self.__flagIsNewFile
430 self.filename
431 self.fileSize
432 self.__fp
433 self.__set
434 self.noMoreFiles
435
436 Return:
437 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
438 1 : si el file fue abierto con exito y esta listo a ser leido
274
439
440 Excepciones:
441 Si un determinado file no puede ser abierto
442 """
275 countFiles = 0
443 countFiles = 0
276 countTries = 0
444 countTries = 0
277
445
278 fileStatus = False
446 fileStatus = 0
447 notFirstTime_flag = False
448 bChangeDir = False
449
450 fileSize = 0
451 fp = None
452
453 self.__flagIsNewFile = 0
454
455 while(True): #este loop permite llevar la cuenta de intentos, de files y carpetas,
456 #si no encuentra alguno sale del bucle
279
457
280 while(True):
281 countFiles += 1
458 countFiles += 1
282
459
283 if countFiles > nFiles+1:
460 if countFiles > (self.__nFiles + 1):
284 break
461 break
285
462
286 self.set += 1
463 self.__set += 1
287
464
288 if countFiles > nFiles:
465 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
289 self.doy += 1
466 self.__set = 0
290 self.set = 0
467 self.__doy += 1
468 bChangeDir = True
291
469
292 doypath = "D%04d%04d" %(self.year, self.doy)
470 file = None
293 filename = "D%04d%04d%03d%s" %(self.year, self.doy, self.set, self.__ext)
471 filename = None
294 file = os.path.join(self.filepath, doypath, filename)
295 fileSize = os.path.getsize(file)
296
472
297 try:
473 countTries = 0
298 fp = open(file)
474
299 except:
475 #espero hasta encontrar el 1er file disponible
300 raise IOError, "The file %s can't be opened" %file
476 while( True ):
477
478 countTries += 1
479 if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
480 break
481
482 file, filename = self.__checkForRealPath()
483 if file != None:
484 break
301
485
486 if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
487 countTries = self.__nTries
488 print "\tsearching next \"%s\" file ..." % filename
489 break
490
491 print "\twaiting new \"%s\" file ..." % filename
492 time.sleep( self.__delay )
493
494 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
495 notFirstTime_flag = True
496 continue #vuelvo al inico del while principal
497
498 countTries = 0
499
500 #una vez que se obtuvo el 1er file valido se procede a checkear su contenido, y se espera una cierta cantidad
501 #de tiempo por una cierta cantidad de veces hasta que el contenido del file sea un contenido valido
302 while(True):
502 while( True ):
303 countTries += 1
503 countTries += 1
304 if countTries > nTries:
504 if countTries > self.__nTries:
505 break
506
507 try:
508 fp = open(file)
509 except:
510 print "The file \"%s\" can't be opened" % file
305 break
511 break
306
512
513 fileSize = os.path.getsize( file )
307 currentSize = fileSize - fp.tell()
514 currentSize = fileSize - fp.tell()
308 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
515 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
309
516
310 if (currentSize < neededSize):
517 if currentSize > neededSize:
311 #waiting for this block
518 fileStatus = 1
312 time.sleep(delay)
313 else:
314 fileStatus = True
315 break
519 break
316
520
317 if fileStatus:
521 fp.close()
522
523 if bChangeDir: #si al buscar un file cambie de directorio ya no espero y salgo del bucle while
524 print "\tsearching next \"%s\" file ..." % filename
318 break
525 break
319
526
320 print "Skipping the file %s due to it hasn't enough data" %filename
527 print "\twaiting for block of \"%s\" file ..." % filename
321 fp.close()
528 time.sleep( self.__delay )
529
530 if fileStatus == 1:
531 break
532
533 print "Skipping the file \"%s\" due to this files is empty" % filename
534 countFiles = 0
535
536
537 if fileStatus == 1:
538 self.fileSize = fileSize
539 self.filename = file#name
540 self.__flagIsNewFile = 1
541 self.__fp = fp
542 self.noMoreFiles = 0
543 print 'Setting the file: %s' % file #name
544 else:
545 self.fileSize = 0
546 self.filename = None
547 self.__fp = None
548 self.noMoreFiles = 1
549 print 'No more Files'
322
550
323 return fileStatus
551 return fileStatus
324
552
553
325 def __setNextFileOffline( self ):
554 def __setNextFileOffline( self ):
555 """
556 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
557
558 Affected:
559 self.__flagIsNewFile
560 self.__idFile
561 self.filename
562 self.fileSize
563 self.__fp
564
565 Return:
566 0 : si un determinado file no puede ser abierto
567 1 : si el file fue abierto con exito
568
569 Excepciones:
570 Si un determinado file no puede ser abierto
571 """
326 idFile = self.__idFile
572 idFile = self.__idFile
573 self.__flagIsNewFile = 0
327
574
328 while(True):
575 while(True):
329 idFile += 1
576 idFile += 1
330
577
331 if not( idFile < len(self.filenameList) ):
578 if not( idFile < len(self.filenameList) ):
332 self.noMoreFiles = 1
579 self.noMoreFiles = 1
333 return 0
580 return 0
334
581
335 filename = self.filenameList[idFile]
582 filename = self.filenameList[idFile]
336 fileSize = os.path.getsize(filename)
583 fileSize = os.path.getsize(filename)
337
584
338 try:
585 try:
339 fp = open( filename, 'rb' )
586 fp = open( filename, 'rb' )
340 except:
587 except:
341 raise IOError, "The file %s can't be opened" %filename
588 raise IOError, "The file %s can't be opened" %filename
342
589
343 currentSize = fileSize - fp.tell()
590 currentSize = fileSize - fp.tell()
344 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
591 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
345
592
346 if (currentSize < neededSize):
593 if (currentSize < neededSize):
347 print "Skipping the file %s due to it hasn't enough data" %filename
594 print "Skipping the file %s due to it hasn't enough data" %filename
348 fp.close()
595 fp.close()
349 continue
596 continue
350
597
351 break
598 break
352
353 self.__flagIsNewFile = 1
599 self.__flagIsNewFile = 1
354 self.__idFile = idFile
600 self.__idFile = idFile
355 self.filename = filename
601 self.filename = filename
356 self.fileSize = fileSize
602 self.fileSize = fileSize
357 self.__fp = fp
603 self.__fp = fp
358
604
359 print 'Setting the file: %s'%self.filename
605 print 'Setting the file: %s'%self.filename
360
606
361 return 1
607 return 1
362
608
609
363 def __setNextFile(self):
610 def __setNextFile( self ):
611 """
612 Determina el siguiente file a leer y si hay uno disponible lee el First Header
364
613
614 Affected:
615 self.m_BasicHeader
616 self.m_SystemHeader
617 self.m_RadarControllerHeader
618 self.m_ProcessingHeader
619 self.firstHeaderSize
620
621 Return:
622 0 : Si no hay files disponibles
623 1 : Si hay mas files disponibles
624 """
365 if self.__fp != None:
625 if self.__fp != None:
366 self.__fp.close()
626 self.__fp.close()
367
627
368 if self.online:
628 if self.online:
369 newFile = self.__setNextFileOnline()
629 newFile = self.__setNextFileOnline()
370 else:
630 else:
371 newFile = self.__setNextFileOffline()
631 newFile = self.__setNextFileOffline()
372
632
373 if not(newFile):
633 if not(newFile):
374 return 0
634 return 0
375
635
376 self.__readFirstHeader()
636 self.__readFirstHeader()
377
637
378 return 1
638 return 1
379
639
640
380 def __setNewBlock( self ):
641 def __setNewBlock( self ):
642 """
643 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
644
645 Affected:
646 self.m_BasicHeader
647 self.flagResetProcessing
648 self.ns
649
650 Return:
651 0 : Si el file no tiene un Basic Header que pueda ser leido
652 1 : Si se pudo leer el Basic Header
653 """
381 if self.__fp == None:
654 if self.__fp == None:
382 return 0
655 return 0
383
656
384 if self.__flagIsNewFile:
657 if self.__flagIsNewFile:
385 return 1
658 return 1
386
659
387 currentSize = self.fileSize - self.__fp.tell()
660 currentSize = self.fileSize - self.__fp.tell()
388 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
661 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
389
662
390 #If there is enough data setting new data block
663 #If there is enough data setting new data block
391 if ( currentSize >= neededSize ):
664 if ( currentSize >= neededSize ):
392 self.__rdBasicHeader()
665 self.__rdBasicHeader()
393 return 1
666 return 1
394
667
395 #Setting new file
668 #Setting new file
396 if not( self.__setNextFile() ):
669 if not( self.__setNextFile() ):
397 return 0
670 return 0
398
671
399 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
672 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
400
673
401 self.flagResetProcessing = 0
674 self.flagResetProcessing = 0
402
675
403 if deltaTime > self.__maxTimeStep:
676 if deltaTime > self.__maxTimeStep:
404 self.flagResetProcessing = 1
677 self.flagResetProcessing = 1
405 self.ns = 0
678 self.ns = 0
406
679
407 return 1
680 return 1
408
681
409
682
410
411 def __readBlock(self):
683 def __readBlock(self):
412 """
684 """
413 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
685 Lee el bloque de datos desde la posicion actual del puntero del archivo
414 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
686 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
415 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
687 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
416 es seteado a 0
688 es seteado a 0
417
689
418 Inputs:
690 Return: None
419 None
420
421 Return:
422 None
423
691
424 Variables afectadas:
692 Variables afectadas:
425
693 self.__datablockIndex
426 self.__buffer_id
427
428 self.__buffer_sspc
429
430 self.__flagIsNewFile
694 self.__flagIsNewFile
431
432 self.flagIsNewBlock
695 self.flagIsNewBlock
433
434 self.nReadBlocks
696 self.nReadBlocks
435
697 self.__data_spc
698 self.__data_cspc
699 self.__data_dc
436 """
700 """
437 Npair_SelfSpectra = 0
701 self.datablock_id = 0
438 Npair_CrossSpectra = 0
439
440 for i in range( 0,self.m_ProcessingHeader.totalSpectra*2,2 ):
441 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
442 Npair_SelfSpectra = Npair_SelfSpectra + 1
443 else:
444 Npair_CrossSpectra = Npair_CrossSpectra + 1
445
446 # self.__buffer_sspc = numpy.concatenate( (data_sspc,data_cspc,data_dcc), axis=0 )
447
448 self.__buffer_id = 0
449 self.__flagIsNewFile = 0
702 self.__flagIsNewFile = 0
450 self.flagIsNewBlock = 1
703 self.flagIsNewBlock = 1
451
704
452 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights
705 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
706 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
707 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
453
708
454 spc = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra))
709 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
455 cspc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra))
456 dc = numpy.fromfile(self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
457
710
458 spc = spc.reshape((Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
711 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
459 cspc = cspc.reshape((Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
712 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
460 dc = dc.reshape((self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights))
461
713
462 if not(self.m_ProcessingHeader.shif_fft):
714 if not( self.m_ProcessingHeader.shif_fft ):
463 spc = numpy.roll(spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
715 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
464 cspc = numpy.roll(cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
716 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
465
717
466 spc = numpy.transpose(spc, (0,2,1))
718 spc = numpy.transpose( spc, (0,2,1) )
467 cspc = numpy.transpose(cspc, (0,2,1))
719 cspc = numpy.transpose( cspc, (0,2,1) )
468 #dc = numpy.transpose(dc, (0,2,1))
720 #dc = numpy.transpose(dc, (0,2,1))
469
721
470 data_spc = spc
722 self.__data_spc = spc
471 data_cspc = cspc['real'] + cspc['imag']*1j
723 self.__data_cspc = cspc['real'] + cspc['imag']*1j
472 data_dc = dc['real'] + dc['imag']*1j
724 self.__data_dc = dc['real'] + dc['imag']*1j
473
474 self.__buffer_spc = data_spc
475 self.__buffer_cspc = data_cspc
476 self.__buffer_dc = data_dc
477
725
478 self.__flagIsNewFile = 0
726 self.__flagIsNewFile = 0
479
727
480 self.flagIsNewBlock = 1
728 self.flagIsNewBlock = 1
481
729
482 self.nReadBlocks += 1
730 self.nReadBlocks += 1
731 self.datablock_id = 0
732
483
733
484
734
485 def __hasNotDataInBuffer(self):
735 def __hasNotDataInBuffer( self ):
736 #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
486 return 1
737 return 1
487
738
488 def __searchFilesOnline(self, path, startDateTime, expLabel = "", ext = ".pdata"):
739
740 def __getlastFileFromPath( self, pathList, ext ):
489 """
741 """
742 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
743 al final de la depuracion devuelve el ultimo file de la lista que quedo.
490
744
745 Input:
746 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
747 ext : extension de los files contenidos en una carpeta
491
748
492 Return:
749 Return:
750 El ultimo file de una determinada carpeta
751 """
493
752
494 filepath
753 filesList = []
754 filename = None
495
755
496 filename
756 # 0123456789ABCDE
757 # PYYYYDDDSSS.ext
497
758
498 year
759 for filename in pathList:
760 year = filename[1:5]
761 doy = filename[5:8]
762 leng = len( ext )
499
763
500 doy
764 if ( filename[-leng:].upper() != ext.upper() ) : continue
765 if not( isNumber( year ) ) : continue
766 if not( isNumber( doy ) ) : continue
501
767
502 set
768 filesList.append(filename)
769
770 if len( filesList ) > 0:
771 #filesList.sort()
772 filesList = sorted( filesList, key=str.lower )
773 filename = filesList[-1]
774
775 return filename
776
777
778 def __searchFilesOnLine( self, path, startDateTime=None, ext = ".pdata" ):
779 """
780 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
781 devuelve el archivo encontrado ademas de otros datos.
782
783 Input:
784 path : carpeta donde estan contenidos los files que contiene data
785 startDateTime : punto especifico en el tiempo del cual se requiere la data
786 ext : extension de los files
503
787
788 Return:
789 year : el anho
790 doy : el numero de dia del anho
791 set : el set del archivo
792 filename : el ultimo file de una determinada carpeta
793 directory : eL directorio donde esta el file encontrado
504 """
794 """
505
795
506 pass
796 print "Searching files ..."
797
798 dirList = []
799 directory = None
800
801 if startDateTime == None:
802 for thisPath in os.listdir(path):
803 if os.path.isdir( os.path.join(path,thisPath) ):
804 dirList.append( thisPath )
805
806 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
807 if len(dirList) > 0 :
808 directory = dirList[-1]
809 else:
810 year = startDateTime.timetuple().tm_year
811 doy = startDateTime.timetuple().tm_yday
812
813 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
814 if os.path.isdir( os.path.join(path,doyPath) ):
815 directory = doyPath
816
817 doyPath = doyPath.lower() #caso del nombre en minusculas
818 if os.path.isdir( os.path.join(path,doyPath) ):
819 directory = doyPath
820
821 if directory == None:
822 return 0, 0, 0, None, None
823
824 filename = self.__getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
825
826 if filename == None:
827 return 0, 0, 0, None, None
828
829 year = int( directory[-7:-3] )
830 doy = int( directory[-3:] )
831 ln = len( ext )
832 set = int( filename[-ln-3:-ln] )
507
833
508 def __searchFilesOffline(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
834 return year, doy, set, filename, directory
835
836
837 def __searchFilesOffLine( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
509 """
838 """
510 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
839 Realiza una busqueda de los archivos que coincidan con los parametros
511 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
840 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
512 correcta la estructura de directorios debe ser la siguiente:
841 correcta la estructura de directorios debe ser la siguiente:
513
842
514 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
843 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
515
844
516 [yyyy]: anio
845 [yyyy]: anio
517 [ddd] : dia del anio
846 [ddd] : dia del anio
518 [sss] : set del archivo
847 [sss] : set del archivo
519
848
520 Inputs:
849 Inputs:
521 path : Directorio de datos donde se realizara la busqueda. Todos los
850 path : Directorio de datos donde se realizara la busqueda. Todos los
522 ficheros que concidan con el criterio de busqueda seran
851 ficheros que concidan con el criterio de busqueda seran
523 almacenados en una lista y luego retornados.
852 almacenados en una lista y luego retornados.
524 startDateTime : Fecha inicial. Rechaza todos los archivos donde
853 startDateTime : Fecha inicial. Rechaza todos los archivos donde
525 file end time < startDateTime (objeto datetime.datetime)
854 file end time < startDateTime (objeto datetime.datetime)
526
855
527 endDateTime : Fecha final. Rechaza todos los archivos donde
856 endDateTime : Fecha final. Rechaza todos los archivos donde
528 file start time > endDateTime (obejto datetime.datetime)
857 file start time > endDateTime (obejto datetime.datetime)
529
858
530 set : Set del primer archivo a leer. Por defecto None
859 set : Set del primer archivo a leer. Por defecto None
531
860
532 expLabel : Nombre del subdirectorio de datos. Por defecto ""
861 expLabel : Nombre del subdirectorio de datos. Por defecto ""
533
862
534 ext : Extension de los archivos a leer. Por defecto .r
863 ext : Extension de los archivos a leer. Por defecto .r
535
864
536 Return:
865 Return:
537
866
538 (pathList, filenameList)
867 (pathList, filenameList)
539
868
540 pathList : Lista de directorios donde se encontraron archivos dentro
869 pathList : Lista de directorios donde se encontraron archivos dentro
541 de los parametros especificados
870 de los parametros especificados
542 filenameList : Lista de archivos (ruta completa) que coincidieron con los
871 filenameList : Lista de archivos (ruta completa) que coincidieron con los
543 parametros especificados.
872 parametros especificados.
544
873
545 Variables afectadas:
874 Variables afectadas:
546
875
547 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
876 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
548 como fuente para leer los bloque de datos, si se termina
877 como fuente para leer los bloque de datos, si se termina
549 de leer todos los bloques de datos de un determinado
878 de leer todos los bloques de datos de un determinado
550 archivo se pasa al siguiente archivo de la lista.
879 archivo se pasa al siguiente archivo de la lista.
551
552 Excepciones:
553
554 """
880 """
555
881
556 print "Searching files ..."
882 print "Searching files ..."
557
883
558 dirList = []
884 dirList = []
559 for thisPath in os.listdir(path):
885 for thisPath in os.listdir(path):
560 if os.path.isdir(os.path.join(path,thisPath)):
886 if os.path.isdir(os.path.join(path,thisPath)):
561 dirList.append(thisPath)
887 dirList.append(thisPath)
562
888
563 pathList = []
889 pathList = []
564
890
565 thisDateTime = startDateTime
891 thisDateTime = startDateTime
566
892
567 while(thisDateTime <= endDateTime):
893 while(thisDateTime <= endDateTime):
568 year = thisDateTime.timetuple().tm_year
894 year = thisDateTime.timetuple().tm_year
569 doy = thisDateTime.timetuple().tm_yday
895 doy = thisDateTime.timetuple().tm_yday
570
896
571 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
897 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
572 if len(match) == 0:
898 if len(match) == 0:
573 thisDateTime += datetime.timedelta(1)
899 thisDateTime += datetime.timedelta(1)
574 continue
900 continue
575
901
576 pathList.append(os.path.join(path,match[0],expLabel))
902 pathList.append(os.path.join(path,match[0],expLabel))
577 thisDateTime += datetime.timedelta(1)
903 thisDateTime += datetime.timedelta(1)
578
904
579 startUtSeconds = time.mktime(startDateTime.timetuple())
905 startUtSeconds = time.mktime(startDateTime.timetuple())
580 endUtSeconds = time.mktime(endDateTime.timetuple())
906 endUtSeconds = time.mktime(endDateTime.timetuple())
581
907
582 filenameList = []
908 filenameList = []
583 for thisPath in pathList:
909 for thisPath in pathList:
584 fileList = glob.glob1(thisPath, "*%s" %ext)
910 fileList = glob.glob1(thisPath, "*%s" %ext)
585 fileList.sort()
911 fileList.sort()
586 for file in fileList:
912 for file in fileList:
587 filename = os.path.join(thisPath,file)
913 filename = os.path.join(thisPath,file)
588 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
914 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
589 filenameList.append(filename)
915 filenameList.append(filename)
590
916
591 self.filenameList = filenameList
917 self.filenameList = filenameList
592
918
593 return pathList, filenameList
919 return pathList, filenameList
594
920
595
921
596 def __searchFiles(self, path, startDateTime, endDateTime, set, expLabel, ext, online):
922 def __initFilesOnline( self, path, dirfilename, filename ):
923 """
924 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
925 del file, si no es un file valido espera una cierta cantidad de tiempo a que
926 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
927 devuelve 0 caso contrario devuelve 1
597
928
598 if online:
929 Affected:
599 pathList, filenameList = self.__searchFilesOnline(path, startDateTime, endDateTime, set, expLabel, ext)
930 m_BasicHeader
600 else:
931
601 pathList, filenameList = self.__searchFilesOffline(path, startDateTime, endDateTime, set, expLabel, ext)
932 Return:
933 0 : file no valido para ser leido
934 1 : file valido para ser leido
935 """
936 m_BasicHeader = BasicHeader()
937
938 file = os.path.join( path, dirfilename, filename )
939
940 nTries = 0
941 while(True):
942
943 nTries += 1
944 if nTries > self.__nTries:
945 break
946
947 try:
948 fp = open( file,'rb' ) #lectura binaria
949 except:
950 raise IOError, "The file %s can't be opened" %(file)
951
952 try:
953 m_BasicHeader.read(fp)
954 except:
955 print "The file %s is empty" % filename
956
957 fp.close()
958
959 if m_BasicHeader.size > 24:
960 break
961
962 print 'waiting for new block: try %02d' % ( nTries )
963 time.sleep( self.__delay)
964
965 if m_BasicHeader.size <= 24:
966 return 0
602
967
603 return 1
968 return 1
604
969
605 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
970
971 def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
606 """
972 """
607 setup configura los parametros de lectura de la clase SpectraReader.
973 setup configura los parametros de lectura de la clase SpectraReader.
608
974
609 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
975 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
610 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
976 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
611 self.filenameList.
977 self.filenameList.
612
978
613 Input:
979 Input:
614 path : Directorios donde se ubican los datos a leer. Dentro de este
980 path : Directorios donde se ubican los datos a leer. Dentro de este
615 directorio deberia de estar subdirectorios de la forma:
981 directorio deberia de estar subdirectorios de la forma:
616
982
617 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
983 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
618
984
619 startDateTime : Fecha inicial. Rechaza todos los archivos donde
985 startDateTime : Fecha inicial. Rechaza todos los archivos donde
620 file end time < startDatetime (objeto datetime.datetime)
986 file end time < startDatetime (objeto datetime.datetime)
621
987
622 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
988 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
623 file end time < startDatetime (objeto datetime.datetime)
989 file end time < startDatetime (objeto datetime.datetime)
624
990
625 set : Set del primer archivo a leer. Por defecto None
991 set : Set del primer archivo a leer. Por defecto None
626
992
627 expLabel : Nombre del subdirectorio de datos. Por defecto ""
993 expLabel : Nombre del subdirectorio de datos. Por defecto ""
628
994
629 ext : Extension de los archivos a leer. Por defecto .r
995 ext : Extension de los archivos a leer. Por defecto .pdata
630
996
631 online :
997 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
632
998
633 Return:
999 Return:
1000 0 : Si no encuentra files que cumplan con las condiciones dadas
1001 1 : Si encuentra files que cumplan con las condiciones dadas
634
1002
635 Affected:
1003 Affected:
1004 self.startUTCSeconds
1005 self.endUTCSeconds
1006 self.startYear
1007 self.endYear
1008 self.startDoy
1009 self.endDoy
1010 self.__pathList
1011 self.filenameList
1012 self.online
1013 """
636
1014
637 Excepciones:
1015 if online:
1016 nTries = 0
1017 while( nTries < self.__nTries ):
1018 nTries += 1
1019 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year,startDateTime.timetuple().tm_yday )
1020 file = os.path.join( path, subfolder )
1021 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries )
1022 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1023 if filename == None:
1024 time.sleep( self.__delay )
1025 else:
1026 break
638
1027
639 Example:
1028 if filename == None:
1029 print "No files On Line"
1030 return 0
640
1031
641 """
1032 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
642 if online == 0:
1033 print "The file %s hasn't enough data"
643 pathList, filenameList = self.__searchFilesOffline(path, startDateTime, endDateTime, set, expLabel, ext)
1034 return 0
644 self.__idFile = -1
1035
1036 self.__year = year
1037 self.__doy = doy
1038 self.__set = set - 1
1039 self.__path = path
645
1040
646 else:
1041 else:
647 filepath, filename, year, doy, set = self.__searchFilesOnline()
1042 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
648 set -= 1
1043 self.__idFile = -1
1044 self.__pathList = pathList
1045 self.filenameList = filenameList
1046
1047 self.online = online
1048 self.__ext = ext
649
1049
650 if not(self.__setNextFile()):
1050 if not(self.__setNextFile()):
1051 if (startDateTime != None) and (endDateTime != None):
651 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1052 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1053 elif startDateTime != None:
1054 print "No files in : %s" % startDateTime.ctime()
1055 else:
1056 print "No files"
652 return 0
1057 return 0
653
1058
1059 if startDateTime != None:
654 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1060 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
655 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
656
657 self.startYear = startDateTime.timetuple().tm_year
1061 self.startYear = startDateTime.timetuple().tm_year
658 self.endYear = endDateTime.timetuple().tm_year
659
660 self.startDoy = startDateTime.timetuple().tm_yday
1062 self.startDoy = startDateTime.timetuple().tm_yday
1063
1064 if endDateTime != None:
1065 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1066 self.endYear = endDateTime.timetuple().tm_year
661 self.endDoy = endDateTime.timetuple().tm_yday
1067 self.endDoy = endDateTime.timetuple().tm_yday
662 #call fillHeaderValues() - to Data Object
1068 #call fillHeaderValues() - to Data Object
663
1069
664 self.__pathList = pathList
1070 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
665 self.filenameList = filenameList
1071 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
666 self.online = online
1072 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
667
1073 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
668 self.__startDateTime = startDateTime
1074 self.m_Spectra.dataType = self.__dataType
669
1075
670 return 1
1076 return 1
671
1077
1078
672 def readNextBlock(self):
1079 def readNextBlock(self):
673 """
1080 """
674 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1081 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
675 mas bloques disponibles en el archivo actual salta al siguiente.
1082 mas bloques disponibles en el archivo actual salta al siguiente.
676
1083
1084 Affected:
1085 self.__lastUTTime
1086
1087 Return: None
677 """
1088 """
678
1089
679 if not( self.__setNewBlock() ):
1090 if not( self.__setNewBlock() ):
680 return 0
1091 return 0
681
1092
1093 if self.online:
1094 nTries = 0
1095 while( nTries < self.__nTries ):
1096 nTries += 1
1097 if self.__readBlock() == 0:
1098 print "Waiting for the next block ..."
1099 time.sleep( self.__delay )
1100 else:
1101 break
1102 else:
682 self.__readBlock()
1103 self.__readBlock()
683
1104
684 self.__lastUTTime = self.m_BasicHeader.utc
1105 self.__lastUTTime = self.m_BasicHeader.utc
685
1106
686 return 1
1107 return 1
687
1108
688
1109
689 def getData(self):
1110 def getData(self):
690 """
1111 """
691 getData copia el buffer de lectura a la clase "Spectra",
1112 Copia el buffer de lectura a la clase "Spectra",
692 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1113 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
693 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1114 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
694
1115
695 Inputs:
696 None
697
698 Return:
1116 Return:
699 data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el
1117 0 : Si no hay mas archivos disponibles
700 buffer. Si no hay mas archivos a leer retorna None.
1118 1 : Si hizo una buena copia del buffer
701
1119
702 Variables afectadas:
1120 Variables afectadas:
703 self.m_Spectra
1121 self.m_Spectra
704 self.__buffer_id
1122 self.__datablockIndex
705
1123 self.flagResetProcessing
706 Excepciones:
1124 self.flagIsNewBlock
707
708 """
1125 """
709
1126
710 self.flagResetProcessing = 0
1127 self.flagResetProcessing = 0
711 self.flagIsNewBlock = 0
1128 self.flagIsNewBlock = 0
712
1129
713 if self.__hasNotDataInBuffer():
1130 if self.__hasNotDataInBuffer():
714 self.readNextBlock()
1131 self.readNextBlock()
715
1132
716 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1133 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
717 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1134 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
718 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1135 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
719 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
1136 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
720 self.m_Spectra.heights = self.__heights
1137 self.m_Spectra.heights = self.__heights
721 self.m_Spectra.dataType = self.__dataType
1138 self.m_Spectra.dataType = self.__dataType
722
1139
723 if self.noMoreFiles == 1:
1140 if self.noMoreFiles == 1:
724 print 'Process finished'
1141 print 'Process finished'
725 return 0
1142 return 0
726
1143
727 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1144 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
728 #print type(self.__buffer_sspc)
729
1145
730 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
1146 self.m_Spectra.flagNoData = False
1147 self.m_Spectra.flagResetProcessing = self.flagResetProcessing
731
1148
732 self.m_Spectra.m_BasicHeader.utc = time
1149 self.m_Spectra.data_spc = self.__data_spc
733 self.m_Spectra.data_spc = self.__buffer_spc
1150 self.m_Spectra.data_cspc = self.__data_cspc
734 self.m_Spectra.data_cspc = self.__buffer_cspc
1151 self.m_Spectra.data_dc = self.__data_dc
735 self.m_Spectra.data_dc = self.__buffer_dc
736
1152
737 #call setData - to Data Object
1153 #call setData - to Data Object
1154 #self.datablock_id += 1
1155 #self.idProfile += 1
738
1156
739 return 1
1157 return 1
740
1158
741
1159
742 class SpectraWriter(DataWriter):
1160 class SpectraWriter( DataWriter ):
1161 """
1162 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
1163 de los datos siempre se realiza por bloques.
1164 """
1165
1166 def __init__( self, m_Spectra = None ):
1167 """
1168 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
1169
1170 Affected:
1171 self.m_Spectra
1172 self.m_BasicHeader
1173 self.m_SystemHeader
1174 self.m_RadarControllerHeader
1175 self.m_ProcessingHeader
1176
1177 Return: None
1178 """
743
1179
744 def __init__(self):
745 if m_Spectra == None:
1180 if m_Spectra == None:
746 m_Spectra = Spectra()
1181 m_Spectra = Spectra()
747
1182
748 self.m_Spectra = m_Spectra
1183 self.m_Spectra = m_Spectra
749
1184
1185 self.__path = None
1186
750 self.__fp = None
1187 self.__fp = None
751
1188
1189 self.__format = None
1190
752 self.__blocksCounter = 0
1191 self.__blocksCounter = 0
753
1192
754 self.__setFile = None
1193 self.__setFile = None
755
1194
756 self.__flagIsNewFile = 0
1195 self.__flagIsNewFile = 1
757
758 self.__buffer_sspc = 0
759
760 self.__buffer_id = 0
761
1196
762 self.__dataType = None
1197 self.__dataType = None
763
1198
764 self.__ext = None
1199 self.__ext = None
765
1200
1201 self.__shape_spc_Buffer = None
1202 self.__shape_cspc_Buffer = None
1203 self.__shape_dc_Buffer = None
1204
766 self.nWriteBlocks = 0
1205 self.nWriteBlocks = 0
767
1206
768 self.flagIsNewBlock = 0
1207 self.flagIsNewBlock = 0
769
1208
770 self.noMoreFiles = 0
1209 self.noMoreFiles = 0
771
1210
772 self.filename = None
1211 self.filename = None
773
1212
774 self.m_BasicHeader= BasicHeader()
1213 self.m_BasicHeader= BasicHeader()
775
1214
776 self.m_SystemHeader = SystemHeader()
1215 self.m_SystemHeader = SystemHeader()
777
1216
778 self.m_RadarControllerHeader = RadarControllerHeader()
1217 self.m_RadarControllerHeader = RadarControllerHeader()
779
1218
780 self.m_ProcessingHeader = ProcessingHeader()
1219 self.m_ProcessingHeader = ProcessingHeader()
781
1220
1221 self.__data_spc = None
1222 self.__data_cspc = None
1223 self.__data_dc = None
1224
1225 def __writeFirstHeader( self ):
1226 """
1227 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1228
1229 Affected:
1230 __dataType
1231
1232 Return:
1233 None
1234 """
1235 self.__writeBasicHeader()
1236 self.__wrSystemHeader()
1237 self.__wrRadarControllerHeader()
1238 self.__wrProcessingHeader()
1239 self.__dataType = self.m_Spectra.dataType
1240
1241 def __writeBasicHeader( self, fp=None ):
1242 """
1243 Escribe solo el Basic header en el file creado
1244
1245 Return:
1246 None
1247 """
1248 if fp == None:
1249 fp = self.__fp
1250
1251 self.m_BasicHeader.write(fp)
1252
1253 def __wrSystemHeader( self, fp=None ):
1254 """
1255 Escribe solo el System header en el file creado
1256
1257 Return:
1258 None
1259 """
1260 if fp == None:
1261 fp = self.__fp
1262
1263 self.m_SystemHeader.write(fp)
1264
1265 def __wrRadarControllerHeader( self, fp=None ):
1266 """
1267 Escribe solo el RadarController header en el file creado
1268
1269 Return:
1270 None
1271 """
1272 if fp == None:
1273 fp = self.__fp
1274
1275 self.m_RadarControllerHeader.write(fp)
1276
1277 def __wrProcessingHeader( self, fp=None ):
1278 """
1279 Escribe solo el Processing header en el file creado
1280
1281 Return:
1282 None
1283 """
1284 if fp == None:
1285 fp = self.__fp
1286
1287 self.m_ProcessingHeader.write(fp)
1288
782 def __setNextFile(self):
1289 def __setNextFile( self ):
783 setFile = self.__setFile
1290 """
1291 Determina el siguiente file que sera escrito
1292
1293 Affected:
1294 self.filename
1295 self.__subfolder
1296 self.__fp
1297 self.__setFile
1298 self.__flagIsNewFile
1299
1300 Return:
1301 0 : Si el archivo no puede ser escrito
1302 1 : Si el archivo esta listo para ser escrito
1303 """
784 ext = self.__ext
1304 ext = self.__ext
785 path = self.__path
1305 path = self.__path
786
1306
787 setFile += 1
1307 if self.__fp != None:
788
789 if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
790 self.__fp.close()
1308 self.__fp.close()
791 return 0
1309
1310 if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
792
1311
793 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
1312 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
794 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
1313 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
795 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
1314
796 tmp = os.path.join(path,subfolder)
1315 tmp = os.path.join( path, subfolder )
797 if not(os.path.exists(tmp)):
1316 if not( os.path.exists(tmp) ):
798 os.mkdir(tmp)
1317 os.mkdir(tmp)
1318 self.__setFile = -1 #inicializo mi contador de seteo
1319 else:
1320 filesList = os.listdir( tmp )
1321 if len( filesList ) > 0:
1322 filesList = sorted( filesList, key=str.lower )
1323 filen = filesList[-1]
1324 # el filename debera tener el siguiente formato
1325 # 0 1234 567 89A BCDE (hex)
1326 # P YYYY DDD SSS .ext
1327 if isNumber( filen[8:11] ):
1328 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1329 else:
1330 self.__setFile = -1
1331 else:
1332 self.__setFile = -1 #inicializo mi contador de seteo
1333
1334 setFile = self.__setFile
1335 setFile += 1
1336 file = 'P%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
799
1337
800 filename = os.path.join(path,subfolder,file)
1338 filename = os.path.join( path, subfolder, file )
1339
801 fp = open(filename,'wb')
1340 fp = open(filename,'wb')
802
1341
1342 self.__blocksCounter = 0
1343
803 #guardando atributos
1344 #guardando atributos
804 self.filename = filename
1345 self.filename = filename
805 self.__subfolder = subfolder
1346 self.__subfolder = subfolder
806 self.__fp = fp
1347 self.__fp = fp
807 self.__setFile = setFile
1348 self.__setFile = setFile
808 self.__flagIsNewFile = 1
1349 self.__flagIsNewFile = 1
809
1350
810 print 'Writing the file: %s'%self.filename
1351 print 'Writing the file: %s'%self.filename
811
1352
812 return 1
1353 self.__writeFirstHeader()
813
814
1354
1355 return 1
815
1356
816 def __setNewBlock(self):
1357 def __setNewBlock( self ):
1358 """
1359 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1360
1361 Return:
1362 0 : si no pudo escribir nada
1363 1 : Si escribio el Basic el First Header
1364 """
817 if self.__fp == None:
1365 if self.__fp == None:
818 return 0
1366 self.__setNextFile()
819
1367
820 if self.__flagIsNewFile:
1368 if self.__flagIsNewFile:
821 return 1
1369 return 1
822
1370
823 #Bloques completados?
1371 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
824 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
825 self.__writeBasicHeader()
1372 self.__writeBasicHeader()
826 return 1
1373 return 1
827
1374
828 if not(self.__setNextFile()):
1375 if not(self.__setNextFile()):
829 return 0
1376 return 0
830
1377
831 self.__writeFirstHeader()
832
833 return 1
1378 return 1
834
1379
835 def __writeBlock(self):
1380 def __writeBlock( self ):
1381 """
1382 Escribe el buffer en el file designado
836
1383
837 numpy.save(self.__fp,self.__buffer_sspc)
1384 Affected:
1385 self.__data_spc
1386 self.__data_cspc
1387 self.__data_dc
1388 self.__flagIsNewFile
1389 self.flagIsNewBlock
1390 self.nWriteBlocks
1391 self.__blocksCounter
1392
1393 Return: None
1394 """
1395 spc = numpy.transpose( self.__data_spc, (0,2,1) )
1396 if not( self.m_ProcessingHeader.shif_fft ):
1397 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1398 data = spc.reshape((-1))
1399 data.tofile(self.__fp)
838
1400
839 self.__buffer_sspc = numpy.array([],self.__dataType)
1401 data = numpy.zeros( self.__shape_cspc_Buffer, self.__dataType )
1402 cspc = numpy.transpose( self.__data_cspc, (0,2,1) )
1403 if not( self.m_ProcessingHeader.shif_fft ):
1404 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
1405 data['real'] = cspc.real
1406 data['imag'] = cspc.imag
1407 data = data.reshape((-1))
1408 data.tofile(self.__fp)
1409
1410 data = numpy.zeros( self.__shape_dc_Buffer, self.__dataType )
1411 dc = self.__data_dc
1412 data['real'] = dc.real
1413 data['imag'] = dc.imag
1414 data = data.reshape((-1))
1415 data.tofile(self.__fp)
840
1416
841 self.__buffer_id = 0
1417 self.__data_spc.fill(0)
1418 self.__data_cspc.fill(0)
1419 self.__data_dc.fill(0)
842
1420
843 self.__flagIsNewFile = 0
1421 self.__flagIsNewFile = 0
844
1422
845 self.flagIsNewBlock = 1
1423 self.flagIsNewBlock = 1
846
1424
847 self.nWriteBlocks += 1
1425 self.nWriteBlocks += 1
848
1426
849 self.__blocksCounter += 1
1427 self.__blocksCounter += 1
850
1428
1429
851 def writeNextBlock(self):
1430 def writeNextBlock( self ):
1431 """
1432 Selecciona el bloque siguiente de datos y los escribe en un file
1433
1434 Return:
1435 0 : Si no hizo pudo escribir el bloque de datos
1436 1 : Si no pudo escribir el bloque de datos
1437 """
852 if not(self.__setNewBlock()):
1438 if not( self.__setNewBlock() ):
853 return 0
1439 return 0
854
1440
855 self.__writeBlock()
1441 self.__writeBlock()
856
1442
857 return 1
1443 return 1
858
1444
1445
859 def __hasAllDataInBuffer(self):
1446 def __hasAllDataInBuffer( self ):
860 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
861 return 1
1447 return 1
862
1448
863 return 0
864
1449
865 def putData(self):
1450 def putData( self ):
866 self.flagIsNewBlock = 0
1451 """
1452 Setea un bloque de datos y luego los escribe en un file
867
1453
868 if self.m_Spectra.noData:
1454 Affected:
869 return None
1455 self.__data_spc
1456 self.__data_cspc
1457 self.__data_dc
870
1458
871 shape = self.m_Spectra.data.shape
1459 Return:
872 data = numpy.zeros(shape,self.__dataType)
1460 0 : Si no hay data o no hay mas files que puedan escribirse
873 data['real'] = self.m_Spectra.data.real
1461 1 : Si se escribio la data de un bloque en un file
874 data['imag'] = self.m_Spectra.data.imag
1462 """
875 data = data.reshape((-1))
1463 self.flagIsNewBlock = 0
1464
1465 if self.m_Spectra.flagNoData:
1466 return 0
876
1467
877 self.__buffer_sspc = numpy.hstack((self.__buffer_sspc,data))
1468 if self.m_Spectra.flagResetProcessing:
1469 self.__data_spc.fill(0)
1470 self.__data_cspc.fill(0)
1471 self.__data_dc.fill(0)
1472 self.__setNextFile()
878
1473
879 self.__buffer_id += 1
1474 self.__data_spc = self.m_Spectra.data_spc
1475 self.__data_cspc = self.m_Spectra.data_cspc
1476 self.__data_dc = self.m_Spectra.data_dc
880
1477
881 if __hasAllDataInBuffer():
1478 if True:
1479 time.sleep( 3 )
1480 self.__getHeader()
882 self.writeNextBlock()
1481 self.writeNextBlock()
883
1482
884
885 if self.noMoreFiles:
1483 if self.noMoreFiles:
886 print 'Process finished'
1484 #print 'Process finished'
887 return None
1485 return 0
888
1486
889 return 1
1487 return 1
890
1488
1489 def __getHeader( self ):
1490 """
1491 Obtiene una copia del First Header
891
1492
892 def setup(self,path,set=None,format=None):
1493 Affected:
1494 self.m_BasicHeader
1495 self.m_SystemHeader
1496 self.m_RadarControllerHeader
1497 self.m_ProcessingHeader
1498 self.__dataType
1499
1500 Return:
1501 None
1502 """
1503 self.m_BasicHeader = self.m_Spectra.m_BasicHeader.copy()
1504 self.m_SystemHeader = self.m_Spectra.m_SystemHeader.copy()
1505 self.m_RadarControllerHeader = self.m_Spectra.m_RadarControllerHeader.copy()
1506 self.m_ProcessingHeader = self.m_Spectra.m_ProcessingHeader.copy()
1507 self.__dataType = self.m_Spectra.dataType
1508
1509 def __setHeaderByFile(self):
1510
1511 format = self.__format
1512 header = ['Basic','System','RadarController','Processing']
1513
1514 fmtFromFile = None
1515 headerFromFile = None
1516
1517
1518 fileTable = self.__configHeaderFile
1519
1520 if os.access(fileTable, os.R_OK):
1521 import re, string
1522
1523 f = open(fileTable,'r')
1524 lines = f.read()
1525 f.close()
1526
1527 #Delete comments into expConfig
1528 while 1:
1529
1530 startComment = string.find(lines.lower(),'#')
1531 if startComment == -1:
1532 break
1533 endComment = string.find(lines.lower(),'\n',startComment)
1534 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1535
1536 while expFromFile == None:
1537
1538 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1539 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1540
1541 if currFmt == -1:
1542 break
1543 if nextFmt == -1:
1544 nextFmt = len(lines)-1
1545
1546 fmtTable = lines[currFmt:nextFmt]
1547 lines = lines[nextFmt:]
1548
1549 fmtRead = self.__getValueFromArg(fmtTable,'format')
1550 if fmtRead != format:
1551 continue
1552 fmtFromFile = fmtRead
1553
1554 lines2 = fmtTable
1555
1556 while headerFromFile == None:
1557
1558 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1559 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1560
1561 if currHeader == -1:
1562 break
1563 if nextHeader == -1:
1564 nextHeader = len(lines2)-1
1565
1566 headerTable = lines2[currHeader:nextHeader]
1567 lines2 = lines2[nextHeader:]
1568
1569 headerRead = self.__getValueFromArg(headerTable,'site')
1570 if not(headerRead in header):
1571 continue
1572 headerFromFile = headerRead
1573
1574 if headerRead == 'Basic':
1575 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1576 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1577 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1578 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1579 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1580 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1581 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1582 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
893
1583
894 if set == None:
895 set = -1
896 else:
1584 else:
897 set -= 1
1585 print "file access denied:%s"%fileTable
1586 sys.exit(0)
1587
1588 def setup( self, path, format='pdata' ):
1589 """
1590 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1591
1592 Inputs:
1593 path : el path destino en el cual se escribiran los files a crear
1594 format : formato en el cual sera salvado un file
898
1595
1596 Return:
1597 0 : Si no realizo un buen seteo
1598 1 : Si realizo un buen seteo
1599 """
899 if format == 'hdf5':
1600 if format == 'hdf5':
900 ext = '.hdf5'
1601 ext = '.hdf5'
1602 format = 'hdf5'
901 print 'call hdf5 library'
1603 print 'call hdf5 library'
902 return 0
1604 return 0
903
1605
904 if format == 'rawdata':
1606 if format == 'rawdata':
905 ext = '.r'
1607 ext = '.r'
1608 format = 'Jicamarca'
906
1609
907 #call to config_headers
1610 if format == 'pdata':
1611 ext = '.pdata'
1612 format = 'pdata'
908
1613
909 self.__setFile = set
1614 #call to config_headers
1615 #self.__setHeaderByFile()
910
1616
911 if not(self.__setNextFile()):
1617 self.__path = path
912 print "zzzzzzzzzzzz"
1618 self.__setFile = -1
913 return 0
1619 self.__ext = ext
1620 self.__format = format
914
1621
915 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
1622 self.__getHeader()
916
1623
917 self.__buffer_sspc = numpy.array([],self.__dataType)
1624 self.__shape_spc_Buffer = ( self.m_Spectra.nChannels,
1625 self.m_ProcessingHeader.numHeights,
1626 self.m_ProcessingHeader.profilesPerBlock
1627 )
918
1628
1629 self.__shape_cspc_Buffer = ( self.m_Spectra.nPairs,
1630 self.m_ProcessingHeader.numHeights,
1631 self.m_ProcessingHeader.profilesPerBlock
1632 )
919
1633
1634 self.__shape_dc_Buffer = ( self.m_SystemHeader.numChannels,
1635 self.m_ProcessingHeader.numHeights
1636 )
920
1637
921 def __writeBasicHeader(self):
1638 if not( self.__setNextFile() ):
922 pass
1639 print "There isn't a next file" #"zzzzzzzzzzzz"
1640 return 0
923
1641
924 def __writeFirstHeader(self):
1642 return 1 No newline at end of file
925 pass
General Comments 0
You need to be logged in to leave comments. Login now