##// END OF EJS Templates
schain
RSS
DataIO.py...
Victor Sarmiento -
r77:3a62c06f85f2
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1184 +1,1268
1 '''
1 '''
2 Created on 23/01/2012
2 Created on 23/01/2012
3
3
4 @author $Author$
4 @author $Author$
5 @version $Id$
5 @version $Id$
6 @version $Id$
6 @version $Id$
7 '''
7 '''
8
8
9 import os, sys
9 import os, sys
10 import glob
10 import glob
11 import time
11 import time
12 import numpy
12 import numpy
13 import fnmatch
13 import fnmatch
14 import time, datetime
14 import time, datetime
15
15
16 path = os.path.split(os.getcwd())[0]
16 path = os.path.split(os.getcwd())[0]
17 sys.path.append(path)
17 sys.path.append(path)
18
18
19 from Model.JROHeader import *
19 from Model.JROHeader import *
20 from Model.JROData import JROData
20 from Model.JROData import JROData
21
21
22 def checkForRealPath(path, year, doy, set, ext):
22 def checkForRealPath(path, year, doy, set, ext):
23 """
23 """
24 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
24 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
25 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
25 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
26 el path exacto de un determinado file.
26 el path exacto de un determinado file.
27
27
28 Example :
28 Example :
29 nombre correcto del file es .../.../D2009307/P2009307367.ext
29 nombre correcto del file es .../.../D2009307/P2009307367.ext
30
30
31 Entonces la funcion prueba con las siguientes combinaciones
31 Entonces la funcion prueba con las siguientes combinaciones
32 .../.../x2009307/y2009307367.ext
32 .../.../x2009307/y2009307367.ext
33 .../.../x2009307/Y2009307367.ext
33 .../.../x2009307/Y2009307367.ext
34 .../.../X2009307/y2009307367.ext
34 .../.../X2009307/y2009307367.ext
35 .../.../X2009307/Y2009307367.ext
35 .../.../X2009307/Y2009307367.ext
36 siendo para este caso, la ultima combinacion de letras, identica al file buscado
36 siendo para este caso, la ultima combinacion de letras, identica al file buscado
37
37
38 Return:
38 Return:
39 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
39 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
40 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
40 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
41 para el filename
41 para el filename
42 """
42 """
43 filepath = None
43 filepath = None
44 find_flag = False
44 find_flag = False
45 filename = None
45 filename = None
46
46
47 if ext.lower() == ".r": #voltage
47 if ext.lower() == ".r": #voltage
48 header1 = "dD"
48 header1 = "dD"
49 header2 = "dD"
49 header2 = "dD"
50 elif ext.lower() == ".pdata": #spectra
50 elif ext.lower() == ".pdata": #spectra
51 header1 = "dD"
51 header1 = "dD"
52 header2 = "pP"
52 header2 = "pP"
53 else:
53 else:
54 return None, filename
54 return None, filename
55
55
56 for dir in header1: #barrido por las dos combinaciones posibles de "D"
56 for dir in header1: #barrido por las dos combinaciones posibles de "D"
57 for fil in header2: #barrido por las dos combinaciones posibles de "D"
57 for fil in header2: #barrido por las dos combinaciones posibles de "D"
58 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
58 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
59 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
59 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
60 filepath = os.path.join( path, doypath, filename ) #formo el path completo
60 filepath = os.path.join( path, doypath, filename ) #formo el path completo
61 if os.path.exists( filepath ): #verifico que exista
61 if os.path.exists( filepath ): #verifico que exista
62 find_flag = True
62 find_flag = True
63 break
63 break
64 if find_flag:
64 if find_flag:
65 break
65 break
66
66
67 if not(find_flag):
67 if not(find_flag):
68 return None, filename
68 return None, filename
69
69
70 return filepath, filename
70 return filepath, filename
71
71
72
72
73 def isNumber(str):
73 def isNumber(str):
74 """
74 """
75 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
75 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
76
76
77 Excepciones:
77 Excepciones:
78 Si un determinado string no puede ser convertido a numero
78 Si un determinado string no puede ser convertido a numero
79 Input:
79 Input:
80 str, string al cual se le analiza para determinar si convertible a un numero o no
80 str, string al cual se le analiza para determinar si convertible a un numero o no
81
81
82 Return:
82 Return:
83 True : si el string es uno numerico
83 True : si el string es uno numerico
84 False : no es un string numerico
84 False : no es un string numerico
85 """
85 """
86 try:
86 try:
87 float( str )
87 float( str )
88 return True
88 return True
89 except:
89 except:
90 return False
90 return False
91
91
92
92
93 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
93 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
94 """
94 """
95 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
95 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
96
96
97 Inputs:
97 Inputs:
98 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
98 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
99
99
100 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
100 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
101 segundos contados desde 01/01/1970.
101 segundos contados desde 01/01/1970.
102 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
102 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
103 segundos contados desde 01/01/1970.
103 segundos contados desde 01/01/1970.
104
104
105 Return:
105 Return:
106 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
106 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
107 fecha especificado, de lo contrario retorna False.
107 fecha especificado, de lo contrario retorna False.
108
108
109 Excepciones:
109 Excepciones:
110 Si el archivo no existe o no puede ser abierto
110 Si el archivo no existe o no puede ser abierto
111 Si la cabecera no puede ser leida.
111 Si la cabecera no puede ser leida.
112
112
113 """
113 """
114 m_BasicHeader = BasicHeader()
114 m_BasicHeader = BasicHeader()
115
115
116 try:
116 try:
117 fp = open(filename,'rb')
117 fp = open(filename,'rb')
118 except:
118 except:
119 raise IOError, "The file %s can't be opened" %(filename)
119 raise IOError, "The file %s can't be opened" %(filename)
120
120
121 sts = m_BasicHeader.read(fp)
121 sts = m_BasicHeader.read(fp)
122 fp.close()
122 fp.close()
123
123
124 if not(sts):
124 if not(sts):
125 print "Skipping the file %s because it has not a valid header" %(filename)
125 print "Skipping the file %s because it has not a valid header" %(filename)
126 return 0
126 return 0
127
127
128 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
128 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
129 return 0
129 return 0
130
130
131 return 1
131 return 1
132
132
133
133
134 def getlastFileFromPath(path, ext):
134 def getlastFileFromPath(path, ext):
135 """
135 """
136 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
136 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
137 al final de la depuracion devuelve el ultimo file de la lista que quedo.
137 al final de la depuracion devuelve el ultimo file de la lista que quedo.
138
138
139 Input:
139 Input:
140 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
140 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
141 ext : extension de los files contenidos en una carpeta
141 ext : extension de los files contenidos en una carpeta
142
142
143 Return:
143 Return:
144 El ultimo file de una determinada carpeta, no se considera el path.
144 El ultimo file de una determinada carpeta, no se considera el path.
145 """
145 """
146 validFilelist = []
146 validFilelist = []
147 fileList = os.listdir(path)
147 fileList = os.listdir(path)
148
148
149 # 0 1234 567 89A BCDE
149 # 0 1234 567 89A BCDE
150 # H YYYY DDD SSS .ext
150 # H YYYY DDD SSS .ext
151
151
152 for file in fileList:
152 for file in fileList:
153 try:
153 try:
154 year = int(file[1:5])
154 year = int(file[1:5])
155 doy = int(file[5:8])
155 doy = int(file[5:8])
156
156
157 if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
157 if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
158 except:
158 except:
159 continue
159 continue
160
160
161 validFilelist.append(file)
161 validFilelist.append(file)
162
162
163 if validFilelist:
163 if validFilelist:
164 validFilelist = sorted( validFilelist, key=str.lower )
164 validFilelist = sorted( validFilelist, key=str.lower )
165 return validFilelist[-1]
165 return validFilelist[-1]
166
166
167 return None
167 return None
168
168
169
169
170 class DataReader():
170 class DataReader():
171
171
172 def __init__(self):
172 def __init__(self):
173 pass
173 pass
174
174
175
175
176 class DataWriter():
176 class DataWriter():
177
177
178 def __init__(self):
178 def __init__(self):
179 pass
179 pass
180
180
181
181
182 class JRODataReader(DataReader):
182 class JRODataReader(DataReader):
183
183
184 """
184 """
185 Esta clase es usada como la clase padre de las clases DataReader,
185 Esta clase es usada como la clase padre de las clases DataReader,
186 contiene todos lo metodos necesarios para leer datos desde archivos en formato
186 contiene todos lo metodos necesarios para leer datos desde archivos en formato
187 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
187 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
188 leidos son array de 3 dimensiones:
188 leidos son array de 3 dimensiones:
189
189
190 Para Voltajes - perfiles * alturas * canales
190 Para Voltajes - perfiles * alturas * canales
191
191
192 Para Spectra - paresCanalesIguales * alturas * perfiles (Self Spectra)
192 Para Spectra - paresCanalesIguales * alturas * perfiles (Self Spectra)
193 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
193 paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
194 canales * alturas (DC Channels)
194 canales * alturas (DC Channels)
195
195
196 y son almacenados en su buffer respectivo.
196 y son almacenados en su buffer respectivo.
197
197
198 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
198 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
199 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
199 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
200 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
200 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
201 el buffer cada vez que se ejecute el metodo "getData".
201 el buffer cada vez que se ejecute el metodo "getData".
202 """
202 """
203
203
204 m_BasicHeader = BasicHeader()
204 m_BasicHeader = BasicHeader()
205
205
206 m_SystemHeader = SystemHeader()
206 m_SystemHeader = SystemHeader()
207
207
208 m_RadarControllerHeader = RadarControllerHeader()
208 m_RadarControllerHeader = RadarControllerHeader()
209
209
210 m_ProcessingHeader = ProcessingHeader()
210 m_ProcessingHeader = ProcessingHeader()
211
211
212 m_DataObj = None
213
214 heightList = None
215
212 online = 0
216 online = 0
213
217
214 fp = None
218 fp = None
215
219
216 fileSizeByHeader = None
220 fileSizeByHeader = None
217
221
218 filenameList = []
222 filenameList = []
219
223
220 filename = None
224 filename = None
221
225
222 fileSize = None
226 fileSize = None
223
227
224 firstHeaderSize = 0
228 firstHeaderSize = 0
225
229
226 basicHeaderSize = 24
230 basicHeaderSize = 24
227
231
228 dataType = None
232 dataType = None
229
233
230 maxTimeStep = 30
234 maxTimeStep = 30
231
235
232 flagNoMoreFiles = 0
236 flagNoMoreFiles = 0
233
237
234 set = 0
238 set = 0
235
239
236 ext = None
240 ext = None
237
241
238 path = None
242 path = None
239
243
240 delay = 3 #seconds
244 delay = 3 #seconds
241
245
242 nTries = 3 #quantity tries
246 nTries = 3 #quantity tries
243
247
244 nFiles = 3 #number of files for searching
248 nFiles = 3 #number of files for searching
245
249
246 nBlocks = 0
250 nBlocks = 0
247
251
248 flagIsNewFile = 1
252 flagIsNewFile = 1
249
253
250 ippSeconds = 0
254 ippSeconds = 0
251
255
252 flagResetProcessing = 0
256 flagResetProcessing = 0
253
257
254 flagIsNewBlock = 0
258 flagIsNewBlock = 0
255
259
256 nReadBlocks = 0
260 nReadBlocks = 0
257
261
258 blocksize = 0
262 blocksize = 0
259
263
260 datablockIndex = 9999
264 datablockIndex = 9999
261
265
266
262 #speed of light
267 #speed of light
263 c = 3E8
268 c = 3E8
264
269
270 def __init__(self, m_DataObj=None):
271 raise ValueError, "This class can't be instanced"
272
273
274
275
276
277 def hasNotDataInBuffer(self):
278 raise ValueError, "Not implemented"
279
280
281 def readBlock(self):
282 raise ValueError, "This method has not been implemented"
283
284 def getData( self ):
285 raise ValueError, "This method has not been implemented"
265
286
266 def __rdSystemHeader(self, fp=None):
287 def __rdSystemHeader(self, fp=None):
267
288
268 if fp == None:
289 if fp == None:
269 fp = self.fp
290 fp = self.fp
270
291
271 self.m_SystemHeader.read(fp)
292 self.m_SystemHeader.read(fp)
272
293
273
294
274 def __rdRadarControllerHeader(self, fp=None):
295 def __rdRadarControllerHeader(self, fp=None):
275 if fp == None:
296 if fp == None:
276 fp = self.fp
297 fp = self.fp
277
298
278 self.m_RadarControllerHeader.read(fp)
299 self.m_RadarControllerHeader.read(fp)
279
300
280
301
281 def __rdProcessingHeader(self, fp=None):
302 def __rdProcessingHeader(self, fp=None):
282 if fp == None:
303 if fp == None:
283 fp = self.fp
304 fp = self.fp
284
305
285 self.m_ProcessingHeader.read(fp)
306 self.m_ProcessingHeader.read(fp)
286
307
287
308
288 def __rdBasicHeader(self, fp=None):
309 def __rdBasicHeader(self, fp=None):
289
310
290 if fp == None:
311 if fp == None:
291 fp = self.fp
312 fp = self.fp
292
313
293 self.m_BasicHeader.read(fp)
314 self.m_BasicHeader.read(fp)
294
315
295
316 def getBlockDimension(self):
317 raise ValueError, "No implemented"
318
296 def __readFirstHeader(self):
319 def __readFirstHeader(self):
297 """
320 """
298 Lectura del First Header, es decir el Basic Header y el Long Header
321 Lectura del First Header, es decir el Basic Header y el Long Header
299
322
300 Affected:
323 Affected:
301 self.m_BasicHeader
324 self.m_BasicHeader
302 self.m_SystemHeader
325 self.m_SystemHeader
303 self.m_RadarControllerHeader
326 self.m_RadarControllerHeader
304 self.m_ProcessingHeader
327 self.m_ProcessingHeader
305 self.firstHeaderSize
328 self.firstHeaderSize
306 self.heights
329 self.heightList
307 self.dataType
330 self.dataType
308 self.fileSizeByHeader
331 self.fileSizeByHeader
309 self.ippSeconds
332 self.ippSeconds
310
333
311 Return:
334 Return:
312 None
335 None
313 """
336 """
314 self.__rdBasicHeader()
337 self.__rdBasicHeader()
315 self.__rdSystemHeader()
338 self.__rdSystemHeader()
316 self.__rdRadarControllerHeader()
339 self.__rdRadarControllerHeader()
317 self.__rdProcessingHeader()
340 self.__rdProcessingHeader()
318 self.firstHeaderSize = self.m_BasicHeader.size
341 self.firstHeaderSize = self.m_BasicHeader.size
319
342
320 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
343 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
321 if data_type == 0:
344 if data_type == 0:
322 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
345 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
323
346
324 elif data_type == 1:
347 elif data_type == 1:
325 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
348 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
326
349
327 elif data_type == 2:
350 elif data_type == 2:
328 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
351 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
329
352
330 elif data_type == 3:
353 elif data_type == 3:
331 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
354 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
332
355
333 elif data_type == 4:
356 elif data_type == 4:
334 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
357 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
335
358
336 elif data_type == 5:
359 elif data_type == 5:
337 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
360 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
338
361
339 else:
362 else:
340 raise ValueError, 'Data type was not defined'
363 raise ValueError, 'Data type was not defined'
341
364
342 xi = self.m_ProcessingHeader.firstHeight
365 xi = self.m_ProcessingHeader.firstHeight
343 step = self.m_ProcessingHeader.deltaHeight
366 step = self.m_ProcessingHeader.deltaHeight
344 xf = xi + self.m_ProcessingHeader.numHeights*step
367 xf = xi + self.m_ProcessingHeader.numHeights*step
345
368
346 self.heights = numpy.arange(xi, xf, step)
369 self.heightList = numpy.arange(xi, xf, step)
370 self.channelList = numpy.arange(self.m_SystemHeader.numChannels)
347 self.dataType = tmp
371 self.dataType = tmp
348 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
372 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
349 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
373 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
350
374
351 self.getBlockDimension()
375 self.getBlockDimension()
352
376
353
377
354 def __setNextFileOnline(self):
378 def __setNextFileOnline(self):
355 """
379 """
356 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
380 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
357 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
381 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
358 siguientes.
382 siguientes.
359
383
360 Affected:
384 Affected:
361 self.flagIsNewFile
385 self.flagIsNewFile
362 self.filename
386 self.filename
363 self.fileSize
387 self.fileSize
364 self.fp
388 self.fp
365 self.set
389 self.set
366 self.flagNoMoreFiles
390 self.flagNoMoreFiles
367
391
368 Return:
392 Return:
369 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
393 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
370 1 : si el file fue abierto con exito y esta listo a ser leido
394 1 : si el file fue abierto con exito y esta listo a ser leido
371
395
372 Excepciones:
396 Excepciones:
373 Si un determinado file no puede ser abierto
397 Si un determinado file no puede ser abierto
374 """
398 """
375 nFiles = 0
399 nFiles = 0
376 fileOk_flag = False
400 fileOk_flag = False
377 firstTime_flag = True
401 firstTime_flag = True
378
402
379 self.set += 1
403 self.set += 1
380
404
381 #busca el 1er file disponible
405 #busca el 1er file disponible
382 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
406 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
383 if file:
407 if file:
384 if self.__verifyFile(file, False):
408 if self.__verifyFile(file, False):
385 fileOk_flag = True
409 fileOk_flag = True
386
410
387 #si no encuentra un file entonces espera y vuelve a buscar
411 #si no encuentra un file entonces espera y vuelve a buscar
388 if not(fileOk_flag):
412 if not(fileOk_flag):
389 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
413 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
390
414
391 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
415 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
392 tries = self.nTries
416 tries = self.nTries
393 else:
417 else:
394 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
418 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
395
419
396 for nTries in range( tries ):
420 for nTries in range( tries ):
397 if firstTime_flag:
421 if firstTime_flag:
398 print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
422 print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
399 time.sleep( self.delay )
423 time.sleep( self.delay )
400 else:
424 else:
401 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
425 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
402
426
403 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
427 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
404 if file:
428 if file:
405 if self.__verifyFile(file):
429 if self.__verifyFile(file):
406 fileOk_flag = True
430 fileOk_flag = True
407 break
431 break
408
432
409 if fileOk_flag:
433 if fileOk_flag:
410 break
434 break
411
435
412 firstTime_flag = False
436 firstTime_flag = False
413
437
414 print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
438 print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
415 self.set += 1
439 self.set += 1
416
440
417 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
441 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
418 self.set = 0
442 self.set = 0
419 self.doy += 1
443 self.doy += 1
420
444
421 if fileOk_flag:
445 if fileOk_flag:
422 self.fileSize = os.path.getsize( file )
446 self.fileSize = os.path.getsize( file )
423 self.filename = file
447 self.filename = file
424 self.flagIsNewFile = 1
448 self.flagIsNewFile = 1
425 if self.fp != None: self.fp.close()
449 if self.fp != None: self.fp.close()
426 self.fp = open(file)
450 self.fp = open(file)
427 self.flagNoMoreFiles = 0
451 self.flagNoMoreFiles = 0
428 print 'Setting the file: %s' % file
452 print 'Setting the file: %s' % file
429 else:
453 else:
430 self.fileSize = 0
454 self.fileSize = 0
431 self.filename = None
455 self.filename = None
432 self.flagIsNewFile = 0
456 self.flagIsNewFile = 0
433 self.fp = None
457 self.fp = None
434 self.flagNoMoreFiles = 1
458 self.flagNoMoreFiles = 1
435 print 'No more Files'
459 print 'No more Files'
436
460
437 return fileOk_flag
461 return fileOk_flag
438
462
439
463
440 def __setNextFileOffline(self):
464 def __setNextFileOffline(self):
441 """
465 """
442 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
466 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
443
467
444 Affected:
468 Affected:
445 self.flagIsNewFile
469 self.flagIsNewFile
446 self.fileIndex
470 self.fileIndex
447 self.filename
471 self.filename
448 self.fileSize
472 self.fileSize
449 self.fp
473 self.fp
450
474
451 Return:
475 Return:
452 0 : si un determinado file no puede ser abierto
476 0 : si un determinado file no puede ser abierto
453 1 : si el file fue abierto con exito
477 1 : si el file fue abierto con exito
454
478
455 Excepciones:
479 Excepciones:
456 Si un determinado file no puede ser abierto
480 Si un determinado file no puede ser abierto
457 """
481 """
458 idFile = self.fileIndex
482 idFile = self.fileIndex
459 while(True):
483 while(True):
460
484
461 idFile += 1
485 idFile += 1
462
486
463 if not(idFile < len(self.filenameList)):
487 if not(idFile < len(self.filenameList)):
464 self.flagNoMoreFiles = 1
488 self.flagNoMoreFiles = 1
465 print 'No more Files'
489 print 'No more Files'
466 return 0
490 return 0
467
491
468 filename = self.filenameList[idFile]
492 filename = self.filenameList[idFile]
469 fileSize = os.path.getsize(filename)
493 fileSize = os.path.getsize(filename)
470
494
471 try:
495 try:
472 fp = open(filename,'rb')
496 fp = open(filename,'rb')
473 except:
497 except:
474 raise IOError, "The file %s can't be opened" %filename
498 raise IOError, "The file %s can't be opened" %filename
475
499
476 currentSize = fileSize - fp.tell()
500 currentSize = fileSize - fp.tell()
477 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
501 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
478
502
479 if (currentSize < neededSize):
503 if (currentSize < neededSize):
480 print "Skipping the file %s due to it hasn't enough data" %filename
504 print "Skipping the file %s due to it hasn't enough data" %filename
481 continue
505 continue
482
506
483 break
507 break
484
508
485 self.flagIsNewFile = 1
509 self.flagIsNewFile = 1
486 self.fileIndex = idFile
510 self.fileIndex = idFile
487 self.filename = filename
511 self.filename = filename
488 self.fileSize = fileSize
512 self.fileSize = fileSize
489 self.fp = fp
513 self.fp = fp
490
514
491 print 'Setting the file: %s'%self.filename
515 print 'Setting the file: %s'%self.filename
492
516
493 return 1
517 return 1
494
518
495
519
496 def setNextFile(self):
520 def setNextFile(self):
497 """
521 """
498 Determina el siguiente file a leer y si hay uno disponible lee el First Header
522 Determina el siguiente file a leer y si hay uno disponible lee el First Header
499
523
500 Affected:
524 Affected:
501 self.m_BasicHeader
525 self.m_BasicHeader
502 self.m_SystemHeader
526 self.m_SystemHeader
503 self.m_RadarControllerHeader
527 self.m_RadarControllerHeader
504 self.m_ProcessingHeader
528 self.m_ProcessingHeader
505 self.firstHeaderSize
529 self.firstHeaderSize
506
530
507 Return:
531 Return:
508 0 : Si no hay files disponibles
532 0 : Si no hay files disponibles
509 1 : Si hay mas files disponibles
533 1 : Si hay mas files disponibles
510 """
534 """
511 if self.fp != None:
535 if self.fp != None:
512 self.fp.close()
536 self.fp.close()
513
537
514 if self.online:
538 if self.online:
515 newFile = self.__setNextFileOnline()
539 newFile = self.__setNextFileOnline()
516 else:
540 else:
517 newFile = self.__setNextFileOffline()
541 newFile = self.__setNextFileOffline()
518
542
519 if self.flagNoMoreFiles:
543 if self.flagNoMoreFiles:
520 sys.exit(0)
544 sys.exit(0)
521
545
522 if not(newFile):
546 if not(newFile):
523 return 0
547 return 0
524
548
525 self.__readFirstHeader()
549 self.__readFirstHeader()
526 self.nBlocks = 0
550 self.nBlocks = 0
527 return 1
551 return 1
528
552
529
553
530 def __setNewBlock(self):
554 def __setNewBlock(self):
531 """
555 """
532 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
556 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
533
557
534 Affected:
558 Affected:
535 self.m_BasicHeader
559 self.m_BasicHeader
536 self.flagNoContinuousBlock
560 self.flagNoContinuousBlock
537 self.ns
561 self.ns
538
562
539 Return:
563 Return:
540 0 : Si el file no tiene un Basic Header que pueda ser leido
564 0 : Si el file no tiene un Basic Header que pueda ser leido
541 1 : Si se pudo leer el Basic Header
565 1 : Si se pudo leer el Basic Header
542 """
566 """
543 if self.fp == None:
567 if self.fp == None:
544 return 0
568 return 0
545
569
546 if self.flagIsNewFile:
570 if self.flagIsNewFile:
547 return 1
571 return 1
548
572
549 currentSize = self.fileSize - self.fp.tell()
573 currentSize = self.fileSize - self.fp.tell()
550 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
574 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
551
575
552 #If there is enough data setting new data block
576 #If there is enough data setting new data block
553 if ( currentSize >= neededSize ):
577 if ( currentSize >= neededSize ):
554 self.__rdBasicHeader()
578 self.__rdBasicHeader()
555 return 1
579 return 1
556
580
557 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
581 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
558 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
582 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
559 for nTries in range( self.nTries ):
583 for nTries in range( self.nTries ):
560
584
561 fpointer = self.fp.tell()
585 fpointer = self.fp.tell()
562 self.fp.close()
586 self.fp.close()
563
587
564 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
588 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
565 time.sleep( self.delay )
589 time.sleep( self.delay )
566
590
567 self.fp = open( self.filename, 'rb' )
591 self.fp = open( self.filename, 'rb' )
568 self.fp.seek( fpointer )
592 self.fp.seek( fpointer )
569
593
570 self.fileSize = os.path.getsize( self.filename )
594 self.fileSize = os.path.getsize( self.filename )
571 currentSize = self.fileSize - self.fp.tell()
595 currentSize = self.fileSize - self.fp.tell()
572 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
596 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
573
597
574 if ( currentSize >= neededSize ):
598 if ( currentSize >= neededSize ):
575 self.__rdBasicHeader()
599 self.__rdBasicHeader()
576 return 1
600 return 1
577
601
578 #Setting new file
602 #Setting new file
579 if not( self.setNextFile() ):
603 if not( self.setNextFile() ):
580 return 0
604 return 0
581
605
582 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
606 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
583
607
584 self.flagResetProcessing = 0
608 self.flagResetProcessing = 0
585
609
586 if deltaTime > self.maxTimeStep:
610 if deltaTime > self.maxTimeStep:
587 self.flagResetProcessing = 1
611 self.flagResetProcessing = 1
588 #self.nReadBlocks = 0
612 #self.nReadBlocks = 0
589
613
590 return 1
614 return 1
591
615
592
616
593 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
617 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
594 """
618 """
595 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
619 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
596 devuelve el archivo encontrado ademas de otros datos.
620 devuelve el archivo encontrado ademas de otros datos.
597
621
598 Input:
622 Input:
599 path : carpeta donde estan contenidos los files que contiene data
623 path : carpeta donde estan contenidos los files que contiene data
600 startDateTime : punto especifico en el tiempo del cual se requiere la data
624 startDateTime : punto especifico en el tiempo del cual se requiere la data
601 ext : extension de los files
625 ext : extension de los files
602
626
603 Return:
627 Return:
604 year : el anho
628 year : el anho
605 doy : el numero de dia del anho
629 doy : el numero de dia del anho
606 set : el set del archivo
630 set : el set del archivo
607 filename : el ultimo file de una determinada carpeta
631 filename : el ultimo file de una determinada carpeta
608 directory : eL directorio donde esta el file encontrado
632 directory : eL directorio donde esta el file encontrado
609 """
633 """
610 dirList = []
634 dirList = []
611 pathList = []
635 pathList = []
612 directory = None
636 directory = None
613
637
614 for thisPath in os.listdir(path):
638 for thisPath in os.listdir(path):
615 if os.path.isdir(os.path.join(path,thisPath)):
639 if os.path.isdir(os.path.join(path,thisPath)):
616 dirList.append(thisPath)
640 dirList.append(thisPath)
617
641
618 if not(dirList):
642 if not(dirList):
619 return None, None, None, None, None
643 return None, None, None, None, None
620
644
621 dirList = sorted( dirList, key=str.lower )
645 dirList = sorted( dirList, key=str.lower )
622
646
623 if startDateTime:
647 if startDateTime:
624 thisDateTime = startDateTime
648 thisDateTime = startDateTime
625 if endDateTime == None: endDateTime = startDateTime
649 if endDateTime == None: endDateTime = startDateTime
626
650
627 while(thisDateTime <= endDateTime):
651 while(thisDateTime <= endDateTime):
628 year = thisDateTime.timetuple().tm_year
652 year = thisDateTime.timetuple().tm_year
629 doy = thisDateTime.timetuple().tm_yday
653 doy = thisDateTime.timetuple().tm_yday
630
654
631 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
655 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
632 if len(match) == 0:
656 if len(match) == 0:
633 thisDateTime += datetime.timedelta(1)
657 thisDateTime += datetime.timedelta(1)
634 continue
658 continue
635
659
636 pathList.append(os.path.join(path,match[0], expLabel))
660 pathList.append(os.path.join(path,match[0], expLabel))
637 thisDateTime += datetime.timedelta(1)
661 thisDateTime += datetime.timedelta(1)
638
662
639 if not(pathList):
663 if not(pathList):
640 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
664 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
641 return None, None, None, None, None
665 return None, None, None, None, None
642
666
643 directory = pathList[0]
667 directory = pathList[0]
644
668
645 else:
669 else:
646 directory = dirList[-1]
670 directory = dirList[-1]
647 directory = os.path.join(path,directory)
671 directory = os.path.join(path,directory)
648
672
649 filename = getlastFileFromPath(directory, ext)
673 filename = getlastFileFromPath(directory, ext)
650
674
651 if not(filename):
675 if not(filename):
652 return None, None, None, None, None
676 return None, None, None, None, None
653
677
654 if not(self.__verifyFile(os.path.join(directory, filename))):
678 if not(self.__verifyFile(os.path.join(directory, filename))):
655 return None, None, None, None, None
679 return None, None, None, None, None
656
680
657 year = int( filename[1:5] )
681 year = int( filename[1:5] )
658 doy = int( filename[5:8] )
682 doy = int( filename[5:8] )
659 set = int( filename[8:11] )
683 set = int( filename[8:11] )
660
684
661 return directory, filename, year, doy, set
685 return directory, filename, year, doy, set
662
686
663
687
664 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
688 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
665 """
689 """
666 Realiza una busqueda de los archivos que coincidan con los parametros
690 Realiza una busqueda de los archivos que coincidan con los parametros
667 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
691 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
668 correcta la estructura de directorios debe ser la siguiente:
692 correcta la estructura de directorios debe ser la siguiente:
669
693
670 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
694 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
671
695
672 [yyyy]: anio
696 [yyyy]: anio
673 [ddd] : dia del anio
697 [ddd] : dia del anio
674 [sss] : set del archivo
698 [sss] : set del archivo
675
699
676 Inputs:
700 Inputs:
677 path : Directorio de datos donde se realizara la busqueda. Todos los
701 path : Directorio de datos donde se realizara la busqueda. Todos los
678 ficheros que concidan con el criterio de busqueda seran
702 ficheros que concidan con el criterio de busqueda seran
679 almacenados en una lista y luego retornados.
703 almacenados en una lista y luego retornados.
680 startDateTime : Fecha inicial. Rechaza todos los archivos donde
704 startDateTime : Fecha inicial. Rechaza todos los archivos donde
681 file end time < startDateTime (obejto datetime.datetime)
705 file end time < startDateTime (obejto datetime.datetime)
682
706
683 endDateTime : Fecha final. Rechaza todos los archivos donde
707 endDateTime : Fecha final. Rechaza todos los archivos donde
684 file start time > endDateTime (obejto datetime.datetime)
708 file start time > endDateTime (obejto datetime.datetime)
685
709
686 set : Set del primer archivo a leer. Por defecto None
710 set : Set del primer archivo a leer. Por defecto None
687
711
688 expLabel : Nombre del subdirectorio de datos. Por defecto ""
712 expLabel : Nombre del subdirectorio de datos. Por defecto ""
689
713
690 ext : Extension de los archivos a leer. Por defecto .r
714 ext : Extension de los archivos a leer. Por defecto .r
691
715
692 Return:
716 Return:
693
717
694 (pathList, filenameList)
718 (pathList, filenameList)
695
719
696 pathList : Lista de directorios donde se encontraron archivos dentro
720 pathList : Lista de directorios donde se encontraron archivos dentro
697 de los parametros especificados
721 de los parametros especificados
698 filenameList : Lista de archivos (ruta completa) que coincidieron con los
722 filenameList : Lista de archivos (ruta completa) que coincidieron con los
699 parametros especificados.
723 parametros especificados.
700
724
701 Variables afectadas:
725 Variables afectadas:
702
726
703 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
727 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
704 como fuente para leer los bloque de datos, si se termina
728 como fuente para leer los bloque de datos, si se termina
705 de leer todos los bloques de datos de un determinado
729 de leer todos los bloques de datos de un determinado
706 archivo se pasa al siguiente archivo de la lista.
730 archivo se pasa al siguiente archivo de la lista.
707
731
708 Excepciones:
732 Excepciones:
709
733
710 """
734 """
711
735
712 print "Searching files ..."
736 print "Searching files ..."
713
737
714 dirList = []
738 dirList = []
715 for thisPath in os.listdir(path):
739 for thisPath in os.listdir(path):
716 if os.path.isdir(os.path.join(path,thisPath)):
740 if os.path.isdir(os.path.join(path,thisPath)):
717 dirList.append(thisPath)
741 dirList.append(thisPath)
718
742
719 if not(dirList):
743 if not(dirList):
720 return None, None
744 return None, None
721
745
722 pathList = []
746 pathList = []
723
747
724 thisDateTime = startDateTime
748 thisDateTime = startDateTime
725
749
726 while(thisDateTime <= endDateTime):
750 while(thisDateTime <= endDateTime):
727 year = thisDateTime.timetuple().tm_year
751 year = thisDateTime.timetuple().tm_year
728 doy = thisDateTime.timetuple().tm_yday
752 doy = thisDateTime.timetuple().tm_yday
729
753
730 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
754 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
731 if len(match) == 0:
755 if len(match) == 0:
732 thisDateTime += datetime.timedelta(1)
756 thisDateTime += datetime.timedelta(1)
733 continue
757 continue
734
758
735 pathList.append(os.path.join(path,match[0],expLabel))
759 pathList.append(os.path.join(path,match[0],expLabel))
736 thisDateTime += datetime.timedelta(1)
760 thisDateTime += datetime.timedelta(1)
737
761
738 startUtSeconds = time.mktime(startDateTime.timetuple())
762 startUtSeconds = time.mktime(startDateTime.timetuple())
739 endUtSeconds = time.mktime(endDateTime.timetuple())
763 endUtSeconds = time.mktime(endDateTime.timetuple())
740
764
741 filenameList = []
765 filenameList = []
742 for thisPath in pathList:
766 for thisPath in pathList:
743 fileList = glob.glob1(thisPath, "*%s" %ext)
767 fileList = glob.glob1(thisPath, "*%s" %ext)
744 fileList.sort()
768 fileList.sort()
745 for file in fileList:
769 for file in fileList:
746 filename = os.path.join(thisPath,file)
770 filename = os.path.join(thisPath,file)
747 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
771 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
748 filenameList.append(filename)
772 filenameList.append(filename)
749
773
750 if not(filenameList):
774 if not(filenameList):
751 return None, None
775 return None, None
752
776
753 self.filenameList = filenameList
777 self.filenameList = filenameList
754
778
755 return pathList, filenameList
779 return pathList, filenameList
756
780
757
781
758 def __verifyFile(self, filename, msgFlag=True):
782 def __verifyFile(self, filename, msgFlag=True):
759 """
783 """
760 Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
784 Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
761
785
762 Return:
786 Return:
763 0 : file no valido para ser leido
787 0 : file no valido para ser leido
764 1 : file valido para ser leido
788 1 : file valido para ser leido
765 """
789 """
766 m_BasicHeader = BasicHeader()
790 m_BasicHeader = BasicHeader()
767 m_SystemHeader = SystemHeader()
791 m_SystemHeader = SystemHeader()
768 m_RadarControllerHeader = RadarControllerHeader()
792 m_RadarControllerHeader = RadarControllerHeader()
769 m_ProcessingHeader = ProcessingHeader()
793 m_ProcessingHeader = ProcessingHeader()
770 flagFileOK = False
794 flagFileOK = False
771
795
772 try:
796 try:
773 fp = open( filename,'rb' ) #lectura binaria
797 fp = open( filename,'rb' ) #lectura binaria
774 except:
798 except:
775 if msgFlag:
799 if msgFlag:
776 print "The file %s can't be opened" % (filename)
800 print "The file %s can't be opened" % (filename)
777
801
778 try:
802 try:
779 if not( m_BasicHeader.read(fp) ): raise ValueError
803 if not( m_BasicHeader.read(fp) ): raise ValueError
780 if not( m_SystemHeader.read(fp) ): raise ValueError
804 if not( m_SystemHeader.read(fp) ): raise ValueError
781 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
805 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
782 if not( m_ProcessingHeader.read(fp) ): raise ValueError
806 if not( m_ProcessingHeader.read(fp) ): raise ValueError
783 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
807 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
784 if m_BasicHeader.size > self.basicHeaderSize:
808 if m_BasicHeader.size > self.basicHeaderSize:
785 flagFileOK = True
809 flagFileOK = True
786 except:
810 except:
787 if msgFlag:
811 if msgFlag:
788 print "\tThe file %s is empty or it hasn't enough data" % filename
812 print "\tThe file %s is empty or it hasn't enough data" % filename
789
813
790 fp.close()
814 fp.close()
791
815
792 if not(flagFileOK):
816 if not(flagFileOK):
793 return 0
817 return 0
794
818
795 return 1
819 return 1
796
820
797
821
798 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
822 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
799 """
823 """
800 setup configura los parametros de lectura de la clase DataReader.
824 setup configura los parametros de lectura de la clase DataReader.
801
825
802 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
826 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
803 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
827 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
804 self.filenameList.
828 self.filenameList.
805
829
806 Input:
830 Input:
807 path : Directorios donde se ubican los datos a leer. Dentro de este
831 path : Directorios donde se ubican los datos a leer. Dentro de este
808 directorio deberia de estar subdirectorios de la forma:
832 directorio deberia de estar subdirectorios de la forma:
809
833
810 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
834 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
811
835
812 startDateTime : Fecha inicial. Rechaza todos los archivos donde
836 startDateTime : Fecha inicial. Rechaza todos los archivos donde
813 file end time < startDatetime (obejto datetime.datetime)
837 file end time < startDatetime (obejto datetime.datetime)
814
838
815 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
839 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
816 file end time < startDatetime (obejto datetime.datetime)
840 file end time < startDatetime (obejto datetime.datetime)
817
841
818 set : Set del primer archivo a leer. Por defecto None
842 set : Set del primer archivo a leer. Por defecto None
819
843
820 expLabel : Nombre del subdirectorio de datos. Por defecto ""
844 expLabel : Nombre del subdirectorio de datos. Por defecto ""
821
845
822 ext : Extension de los archivos a leer. Por defecto .r
846 ext : Extension de los archivos a leer. Por defecto .r
823
847
824 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
848 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
825
849
826 Return:
850 Return:
827 0 : Si no encuentra files que cumplan con las condiciones dadas
851 0 : Si no encuentra files que cumplan con las condiciones dadas
828 1 : Si encuentra files que cumplan con las condiciones dadas
852 1 : Si encuentra files que cumplan con las condiciones dadas
829
853
830 Affected:
854 Affected:
831 self.startUTCSeconds
855 self.startUTCSeconds
832 self.endUTCSeconds
856 self.endUTCSeconds
833 self.startYear
857 self.startYear
834 self.endYear
858 self.endYear
835 self.startDoy
859 self.startDoy
836 self.endDoy
860 self.endDoy
837 self.pathList
861 self.pathList
838 self.filenameList
862 self.filenameList
839 self.online
863 self.online
840 """
864 """
841
865
842 if ext == None:
866 if ext == None:
843 ext = self.ext
867 ext = self.ext
844
868
845 if online:
869 if online:
846 print "Searching files ..."
870 print "Searching files ..."
847 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
871 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
848
872
849 if not(doypath):
873 if not(doypath):
850 for nTries in range( self.nTries ):
874 for nTries in range( self.nTries ):
851 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
875 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
852 time.sleep( self.delay )
876 time.sleep( self.delay )
853 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
877 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
854 if doypath:
878 if doypath:
855 break
879 break
856
880
857 if not(doypath):
881 if not(doypath):
858 print "There 'isn't valied files in %s" % path
882 print "There 'isn't valied files in %s" % path
859 return 0
883 return 0
860
884
861 self.year = year
885 self.year = year
862 self.doy = doy
886 self.doy = doy
863 self.set = set - 1
887 self.set = set - 1
864 self.path = path
888 self.path = path
865
889
866 else: # offline
890 else: # offline
867 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
891 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
868 if not(pathList):
892 if not(pathList):
869 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
893 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
870 return 0
894 return 0
871
895
872 self.fileIndex = -1
896 self.fileIndex = -1
873 self.pathList = pathList
897 self.pathList = pathList
874 self.filenameList = filenameList
898 self.filenameList = filenameList
875
899
876 self.online = online
900 self.online = online
877 self.ext = ext
901 self.ext = ext
878
902
879 ext = ext.lower()
903 ext = ext.lower()
880
904
881 if not( self.setNextFile() ):
905 if not( self.setNextFile() ):
882 if (startDateTime != None) and (endDateTime != None):
906 if (startDateTime != None) and (endDateTime != None):
883 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
907 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
884 elif startDateTime != None:
908 elif startDateTime != None:
885 print "No files in : %s" % startDateTime.ctime()
909 print "No files in : %s" % startDateTime.ctime()
886 else:
910 else:
887 print "No files"
911 print "No files"
888 return 0
912 return 0
889
913
890 if startDateTime != None:
914 if startDateTime != None:
891 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
915 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
892 self.startYear = startDateTime.timetuple().tm_year
916 self.startYear = startDateTime.timetuple().tm_year
893 self.startDoy = startDateTime.timetuple().tm_yday
917 self.startDoy = startDateTime.timetuple().tm_yday
894
918
895 if endDateTime != None:
919 if endDateTime != None:
896 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
920 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
897 self.endYear = endDateTime.timetuple().tm_year
921 self.endYear = endDateTime.timetuple().tm_year
898 self.endDoy = endDateTime.timetuple().tm_yday
922 self.endDoy = endDateTime.timetuple().tm_yday
899 #call fillHeaderValues() - to Data Object
923 #call fillHeaderValues() - to Data Object
900
924
901 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
925 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
902 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
926 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
903 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
927 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
904 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
928 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
905 self.m_DataObj.dataType = self.dataType
929 self.m_DataObj.dataType = self.dataType
906
930
907 return 1
931 return 1
908
932
909
933
910 def readNextBlock(self):
934 def readNextBlock(self):
911 """
935 """
912 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
936 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
913 mas bloques disponibles en el archivo actual salta al siguiente.
937 mas bloques disponibles en el archivo actual salta al siguiente.
914
938
915 Affected:
939 Affected:
916 self.lastUTTime
940 self.lastUTTime
917
941
918 Return: None
942 Return: None
919 """
943 """
920 if not(self.__setNewBlock()):
944 if not(self.__setNewBlock()):
921 return 0
945 return 0
922
946
923 if not(self.readBlock()):
947 if not(self.readBlock()):
924 return 0
948 return 0
925
949
926 self.lastUTTime = self.m_BasicHeader.utc
950 self.lastUTTime = self.m_BasicHeader.utc
927
951
928 return 1
952 return 1
929
953
930
954
931 class JRODataWriter(DataWriter):
955 class JRODataWriter(DataWriter):
932
956
933 """
957 """
934 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
958 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
935 de los datos siempre se realiza por bloques.
959 de los datos siempre se realiza por bloques.
936 """
960 """
937
961
962 m_BasicHeader = BasicHeader()
963
964 m_SystemHeader = SystemHeader()
965
966 m_RadarControllerHeader = RadarControllerHeader()
967
968 m_ProcessingHeader = ProcessingHeader()
969
938 fp = None
970 fp = None
939
971
940 blocksCounter = 0
972 blocksCounter = 0
941
973
942 flagIsNewFile = 1
974 flagIsNewFile = 1
943
975
944 nWriteBlocks = 0
976 nWriteBlocks = 0
945
977
946 flagIsNewBlock = 0
978 flagIsNewBlock = 0
947
979
948 flagNoMoreFiles = 0
980 flagNoMoreFiles = 0
949
981
982 m_DataObj = None
983
984 fp = None
985
986 blocksCounter = 0
987
988 flagIsNewFile = 1
989
990 nWriteBlocks = 0
991
992 flagIsNewBlock = 0
993
994 flagNoMoreFiles = 0
995
996 setFile = None
997
998 dataType = None
999
1000 path = None
1001
1002 noMoreFiles = 0
1003
1004 filename = None
1005
1006 m_BasicHeader = None
1007
1008 m_SystemHeader = None
1009
1010 m_RadarControllerHeader = None
1011
1012 m_ProcessingHeader = None
1013
1014
1015 def __init__(self, m_DataObj=None):
1016 raise ValueError, "Not implemented"
1017
1018
1019 def hasAllDataInBuffer(self):
1020 raise ValueError, "Not implemented"
1021
1022
1023 def setBlockDimension(self):
1024 raise ValueError, "Not implemented"
1025
1026
1027 def writeBlock(self):
1028 raise ValueError, "No implemented"
1029
1030
1031 def putData(self):
1032 raise ValueError, "No implemented"
1033
950
1034
951 def __writeFirstHeader(self):
1035 def __writeFirstHeader(self):
952 """
1036 """
953 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1037 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
954
1038
955 Affected:
1039 Affected:
956 __dataType
1040 __dataType
957
1041
958 Return:
1042 Return:
959 None
1043 None
960 """
1044 """
961 self.__writeBasicHeader()
1045 self.__writeBasicHeader()
962 self.__wrSystemHeader()
1046 self.__wrSystemHeader()
963 self.__wrRadarControllerHeader()
1047 self.__wrRadarControllerHeader()
964 self.__wrProcessingHeader()
1048 self.__wrProcessingHeader()
965 self.dataType = self.m_DataObj.dataType
1049 self.dataType = self.m_DataObj.dataType
966
1050
967
1051
968 def __writeBasicHeader(self, fp=None):
1052 def __writeBasicHeader(self, fp=None):
969 """
1053 """
970 Escribe solo el Basic header en el file creado
1054 Escribe solo el Basic header en el file creado
971
1055
972 Return:
1056 Return:
973 None
1057 None
974 """
1058 """
975 if fp == None:
1059 if fp == None:
976 fp = self.fp
1060 fp = self.fp
977
1061
978 self.m_DataObj.m_BasicHeader.write(fp)
1062 self.m_DataObj.m_BasicHeader.write(fp)
979
1063
980
1064
981 def __wrSystemHeader(self, fp=None):
1065 def __wrSystemHeader(self, fp=None):
982 """
1066 """
983 Escribe solo el System header en el file creado
1067 Escribe solo el System header en el file creado
984
1068
985 Return:
1069 Return:
986 None
1070 None
987 """
1071 """
988 if fp == None:
1072 if fp == None:
989 fp = self.fp
1073 fp = self.fp
990
1074
991 self.m_DataObj.m_SystemHeader.write(fp)
1075 self.m_DataObj.m_SystemHeader.write(fp)
992
1076
993
1077
994 def __wrRadarControllerHeader(self, fp=None):
1078 def __wrRadarControllerHeader(self, fp=None):
995 """
1079 """
996 Escribe solo el RadarController header en el file creado
1080 Escribe solo el RadarController header en el file creado
997
1081
998 Return:
1082 Return:
999 None
1083 None
1000 """
1084 """
1001 if fp == None:
1085 if fp == None:
1002 fp = self.fp
1086 fp = self.fp
1003
1087
1004 self.m_DataObj.m_RadarControllerHeader.write(fp)
1088 self.m_DataObj.m_RadarControllerHeader.write(fp)
1005
1089
1006
1090
1007 def __wrProcessingHeader(self, fp=None):
1091 def __wrProcessingHeader(self, fp=None):
1008 """
1092 """
1009 Escribe solo el Processing header en el file creado
1093 Escribe solo el Processing header en el file creado
1010
1094
1011 Return:
1095 Return:
1012 None
1096 None
1013 """
1097 """
1014 if fp == None:
1098 if fp == None:
1015 fp = self.fp
1099 fp = self.fp
1016
1100
1017 self.m_DataObj.m_ProcessingHeader.write(fp)
1101 self.m_DataObj.m_ProcessingHeader.write(fp)
1018
1102
1019
1103
1020 def setNextFile(self):
1104 def setNextFile(self):
1021 """
1105 """
1022 Determina el siguiente file que sera escrito
1106 Determina el siguiente file que sera escrito
1023
1107
1024 Affected:
1108 Affected:
1025 self.filename
1109 self.filename
1026 self.subfolder
1110 self.subfolder
1027 self.fp
1111 self.fp
1028 self.setFile
1112 self.setFile
1029 self.flagIsNewFile
1113 self.flagIsNewFile
1030
1114
1031 Return:
1115 Return:
1032 0 : Si el archivo no puede ser escrito
1116 0 : Si el archivo no puede ser escrito
1033 1 : Si el archivo esta listo para ser escrito
1117 1 : Si el archivo esta listo para ser escrito
1034 """
1118 """
1035 ext = self.ext
1119 ext = self.ext
1036 path = self.path
1120 path = self.path
1037
1121
1038 if self.fp != None:
1122 if self.fp != None:
1039 self.fp.close()
1123 self.fp.close()
1040
1124
1041 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1125 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1042 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1126 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1043
1127
1044 tmp = os.path.join( path, subfolder )
1128 tmp = os.path.join( path, subfolder )
1045 if not( os.path.exists(tmp) ):
1129 if not( os.path.exists(tmp) ):
1046 os.mkdir(tmp)
1130 os.mkdir(tmp)
1047 self.setFile = -1 #inicializo mi contador de seteo
1131 self.setFile = -1 #inicializo mi contador de seteo
1048 else:
1132 else:
1049 filesList = os.listdir( tmp )
1133 filesList = os.listdir( tmp )
1050 if len( filesList ) > 0:
1134 if len( filesList ) > 0:
1051 filesList = sorted( filesList, key=str.lower )
1135 filesList = sorted( filesList, key=str.lower )
1052 filen = filesList[-1]
1136 filen = filesList[-1]
1053 # el filename debera tener el siguiente formato
1137 # el filename debera tener el siguiente formato
1054 # 0 1234 567 89A BCDE (hex)
1138 # 0 1234 567 89A BCDE (hex)
1055 # x YYYY DDD SSS .ext
1139 # x YYYY DDD SSS .ext
1056 if isNumber( filen[8:11] ):
1140 if isNumber( filen[8:11] ):
1057 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1141 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1058 else:
1142 else:
1059 self.setFile = -1
1143 self.setFile = -1
1060 else:
1144 else:
1061 self.setFile = -1 #inicializo mi contador de seteo
1145 self.setFile = -1 #inicializo mi contador de seteo
1062
1146
1063 setFile = self.setFile
1147 setFile = self.setFile
1064 setFile += 1
1148 setFile += 1
1065
1149
1066 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1150 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1067 timeTuple.tm_year,
1151 timeTuple.tm_year,
1068 timeTuple.tm_yday,
1152 timeTuple.tm_yday,
1069 setFile,
1153 setFile,
1070 ext )
1154 ext )
1071
1155
1072 filename = os.path.join( path, subfolder, file )
1156 filename = os.path.join( path, subfolder, file )
1073
1157
1074 fp = open( filename,'wb' )
1158 fp = open( filename,'wb' )
1075
1159
1076 self.blocksCounter = 0
1160 self.blocksCounter = 0
1077
1161
1078 #guardando atributos
1162 #guardando atributos
1079 self.filename = filename
1163 self.filename = filename
1080 self.subfolder = subfolder
1164 self.subfolder = subfolder
1081 self.fp = fp
1165 self.fp = fp
1082 self.setFile = setFile
1166 self.setFile = setFile
1083 self.flagIsNewFile = 1
1167 self.flagIsNewFile = 1
1084
1168
1085 print 'Writing the file: %s'%self.filename
1169 print 'Writing the file: %s'%self.filename
1086
1170
1087 self.__writeFirstHeader()
1171 self.__writeFirstHeader()
1088
1172
1089 return 1
1173 return 1
1090
1174
1091
1175
1092 def __setNewBlock(self):
1176 def __setNewBlock(self):
1093 """
1177 """
1094 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1178 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1095
1179
1096 Return:
1180 Return:
1097 0 : si no pudo escribir nada
1181 0 : si no pudo escribir nada
1098 1 : Si escribio el Basic el First Header
1182 1 : Si escribio el Basic el First Header
1099 """
1183 """
1100 if self.fp == None:
1184 if self.fp == None:
1101 self.setNextFile()
1185 self.setNextFile()
1102
1186
1103 if self.flagIsNewFile:
1187 if self.flagIsNewFile:
1104 return 1
1188 return 1
1105
1189
1106 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1190 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1107 self.__writeBasicHeader()
1191 self.__writeBasicHeader()
1108 return 1
1192 return 1
1109
1193
1110 if not( self.setNextFile() ):
1194 if not( self.setNextFile() ):
1111 return 0
1195 return 0
1112
1196
1113 return 1
1197 return 1
1114
1198
1115
1199
1116 def writeNextBlock(self):
1200 def writeNextBlock(self):
1117 """
1201 """
1118 Selecciona el bloque siguiente de datos y los escribe en un file
1202 Selecciona el bloque siguiente de datos y los escribe en un file
1119
1203
1120 Return:
1204 Return:
1121 0 : Si no hizo pudo escribir el bloque de datos
1205 0 : Si no hizo pudo escribir el bloque de datos
1122 1 : Si no pudo escribir el bloque de datos
1206 1 : Si no pudo escribir el bloque de datos
1123 """
1207 """
1124 if not( self.__setNewBlock() ):
1208 if not( self.__setNewBlock() ):
1125 return 0
1209 return 0
1126
1210
1127 self.writeBlock()
1211 self.writeBlock()
1128
1212
1129 return 1
1213 return 1
1130
1214
1131
1215
1132 def getHeader(self):
1216 def getHeader(self):
1133 """
1217 """
1134 Obtiene una copia del First Header
1218 Obtiene una copia del First Header
1135
1219
1136 Affected:
1220 Affected:
1137 self.m_BasicHeader
1221 self.m_BasicHeader
1138 self.m_SystemHeader
1222 self.m_SystemHeader
1139 self.m_RadarControllerHeader
1223 self.m_RadarControllerHeader
1140 self.m_ProcessingHeader
1224 self.m_ProcessingHeader
1141 self.dataType
1225 self.dataType
1142
1226
1143 Return:
1227 Return:
1144 None
1228 None
1145 """
1229 """
1146 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1230 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1147 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1231 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1148 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1232 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1149 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1233 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1150 self.dataType = self.m_DataObj.dataType
1234 self.dataType = self.m_DataObj.dataType
1151
1235
1152
1236
1153 def setup(self, path, set=0, ext=None):
1237 def setup(self, path, set=0, ext=None):
1154 """
1238 """
1155 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1239 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1156
1240
1157 Inputs:
1241 Inputs:
1158 path : el path destino en el cual se escribiran los files a crear
1242 path : el path destino en el cual se escribiran los files a crear
1159 format : formato en el cual sera salvado un file
1243 format : formato en el cual sera salvado un file
1160 set : el setebo del file
1244 set : el setebo del file
1161
1245
1162 Return:
1246 Return:
1163 0 : Si no realizo un buen seteo
1247 0 : Si no realizo un buen seteo
1164 1 : Si realizo un buen seteo
1248 1 : Si realizo un buen seteo
1165 """
1249 """
1166
1250
1167 if ext == None:
1251 if ext == None:
1168 ext = self.ext
1252 ext = self.ext
1169
1253
1170 ext = ext.lower()
1254 ext = ext.lower()
1171
1255
1172 self.path = path
1256 self.path = path
1173 self.setFile = set - 1
1257 self.setFile = set - 1
1174 self.ext = ext
1258 self.ext = ext
1175 #self.format = format
1259 #self.format = format
1176 self.getHeader()
1260 self.getHeader()
1177
1261
1178 self.setBlockDimension()
1262 self.setBlockDimension()
1179
1263
1180 if not( self.setNextFile() ):
1264 if not( self.setNextFile() ):
1181 print "There isn't a next file"
1265 print "There isn't a next file"
1182 return 0
1266 return 0
1183
1267
1184 return 1
1268 return 1
General Comments 0
You need to be logged in to leave comments. Login now