##// END OF EJS Templates
schain
RSS
DataIO.py :...
Victor Sarmiento -
r67:c78ff96dc7e6
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1184 +1,1184
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 online = 0
212 online = 0
213
213
214 fp = None
214 fp = None
215
215
216 fileSizeByHeader = None
216 fileSizeByHeader = None
217
217
218 filenameList = []
218 filenameList = []
219
219
220 filename = None
220 filename = None
221
221
222 fileSize = None
222 fileSize = None
223
223
224 firstHeaderSize = 0
224 firstHeaderSize = 0
225
225
226 basicHeaderSize = 24
226 basicHeaderSize = 24
227
227
228 dataType = None
228 dataType = None
229
229
230 maxTimeStep = 30
230 maxTimeStep = 30
231
231
232 flagNoMoreFiles = 0
232 flagNoMoreFiles = 0
233
233
234 set = 0
234 set = 0
235
235
236 ext = None
236 ext = None
237
237
238 path = None
238 path = None
239
239
240 delay = 3 #seconds
240 delay = 3 #seconds
241
241
242 nTries = 3 #quantity tries
242 nTries = 3 #quantity tries
243
243
244 nFiles = 3 #number of files for searching
244 nFiles = 3 #number of files for searching
245
245
246 nBlocks = 0
246 nBlocks = 0
247
247
248 flagIsNewFile = 1
248 flagIsNewFile = 1
249
249
250 ippSeconds = 0
250 ippSeconds = 0
251
251
252 flagResetProcessing = 0
252 flagResetProcessing = 0
253
253
254 flagIsNewBlock = 0
254 flagIsNewBlock = 0
255
255
256 nReadBlocks = 0
256 nReadBlocks = 0
257
257
258 blocksize = 0
258 blocksize = 0
259
259
260 datablockIndex = 9999
260 datablockIndex = 9999
261
261
262 #speed of light
262 #speed of light
263 c = 3E8
263 c = 3E8
264
264
265
265
266 def __rdSystemHeader(self, fp=None):
266 def __rdSystemHeader(self, fp=None):
267
267
268 if fp == None:
268 if fp == None:
269 fp = self.fp
269 fp = self.fp
270
270
271 self.m_SystemHeader.read(fp)
271 self.m_SystemHeader.read(fp)
272
272
273
273
274 def __rdRadarControllerHeader(self, fp=None):
274 def __rdRadarControllerHeader(self, fp=None):
275 if fp == None:
275 if fp == None:
276 fp = self.fp
276 fp = self.fp
277
277
278 self.m_RadarControllerHeader.read(fp)
278 self.m_RadarControllerHeader.read(fp)
279
279
280
280
281 def __rdProcessingHeader(self, fp=None):
281 def __rdProcessingHeader(self, fp=None):
282 if fp == None:
282 if fp == None:
283 fp = self.fp
283 fp = self.fp
284
284
285 self.m_ProcessingHeader.read(fp)
285 self.m_ProcessingHeader.read(fp)
286
286
287
287
288 def __rdBasicHeader(self, fp=None):
288 def __rdBasicHeader(self, fp=None):
289
289
290 if fp == None:
290 if fp == None:
291 fp = self.fp
291 fp = self.fp
292
292
293 self.m_BasicHeader.read(fp)
293 self.m_BasicHeader.read(fp)
294
294
295
295
296 def __readFirstHeader(self):
296 def __readFirstHeader(self):
297 """
297 """
298 Lectura del First Header, es decir el Basic Header y el Long Header
298 Lectura del First Header, es decir el Basic Header y el Long Header
299
299
300 Affected:
300 Affected:
301 self.m_BasicHeader
301 self.m_BasicHeader
302 self.m_SystemHeader
302 self.m_SystemHeader
303 self.m_RadarControllerHeader
303 self.m_RadarControllerHeader
304 self.m_ProcessingHeader
304 self.m_ProcessingHeader
305 self.firstHeaderSize
305 self.firstHeaderSize
306 self.heights
306 self.heights
307 self.dataType
307 self.dataType
308 self.fileSizeByHeader
308 self.fileSizeByHeader
309 self.ippSeconds
309 self.ippSeconds
310
310
311 Return:
311 Return:
312 None
312 None
313 """
313 """
314 self.__rdBasicHeader()
314 self.__rdBasicHeader()
315 self.__rdSystemHeader()
315 self.__rdSystemHeader()
316 self.__rdRadarControllerHeader()
316 self.__rdRadarControllerHeader()
317 self.__rdProcessingHeader()
317 self.__rdProcessingHeader()
318 self.firstHeaderSize = self.m_BasicHeader.size
318 self.firstHeaderSize = self.m_BasicHeader.size
319
319
320 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
320 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
321 if data_type == 0:
321 if data_type == 0:
322 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
322 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
323
323
324 elif data_type == 1:
324 elif data_type == 1:
325 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
325 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
326
326
327 elif data_type == 2:
327 elif data_type == 2:
328 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
328 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
329
329
330 elif data_type == 3:
330 elif data_type == 3:
331 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
331 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
332
332
333 elif data_type == 4:
333 elif data_type == 4:
334 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
334 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
335
335
336 elif data_type == 5:
336 elif data_type == 5:
337 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
337 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
338
338
339 else:
339 else:
340 raise ValueError, 'Data type was not defined'
340 raise ValueError, 'Data type was not defined'
341
341
342 xi = self.m_ProcessingHeader.firstHeight
342 xi = self.m_ProcessingHeader.firstHeight
343 step = self.m_ProcessingHeader.deltaHeight
343 step = self.m_ProcessingHeader.deltaHeight
344 xf = xi + self.m_ProcessingHeader.numHeights*step
344 xf = xi + self.m_ProcessingHeader.numHeights*step
345
345
346 self.heights = numpy.arange(xi, xf, step)
346 self.heights = numpy.arange(xi, xf, step)
347 self.dataType = tmp
347 self.dataType = tmp
348 self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
348 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
349 self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
350
350
351 self.getBlockDimension()
351 self.getBlockDimension()
352
352
353
353
354 def __setNextFileOnline(self):
354 def __setNextFileOnline(self):
355 """
355 """
356 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
356 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
357 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
358 siguientes.
358 siguientes.
359
359
360 Affected:
360 Affected:
361 self.flagIsNewFile
361 self.flagIsNewFile
362 self.filename
362 self.filename
363 self.fileSize
363 self.fileSize
364 self.fp
364 self.fp
365 self.set
365 self.set
366 self.flagNoMoreFiles
366 self.flagNoMoreFiles
367
367
368 Return:
368 Return:
369 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
369 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
370 1 : si el file fue abierto con exito y esta listo a ser leido
371
371
372 Excepciones:
372 Excepciones:
373 Si un determinado file no puede ser abierto
373 Si un determinado file no puede ser abierto
374 """
374 """
375 nFiles = 0
375 nFiles = 0
376 fileOk_flag = False
376 fileOk_flag = False
377 firstTime_flag = True
377 firstTime_flag = True
378
378
379 self.set += 1
379 self.set += 1
380
380
381 #busca el 1er file disponible
381 #busca el 1er file disponible
382 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
382 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
383 if file:
383 if file:
384 if self.__verifyFile(file, False):
384 if self.__verifyFile(file, False):
385 fileOk_flag = True
385 fileOk_flag = True
386
386
387 #si no encuentra un file entonces espera y vuelve a buscar
387 #si no encuentra un file entonces espera y vuelve a buscar
388 if not(fileOk_flag):
388 if not(fileOk_flag):
389 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
389 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
390
390
391 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
391 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
392 tries = self.nTries
392 tries = self.nTries
393 else:
393 else:
394 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
394 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
395
395
396 for nTries in range( tries ):
396 for nTries in range( tries ):
397 if firstTime_flag:
397 if firstTime_flag:
398 print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
398 print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
399 time.sleep( self.delay )
399 time.sleep( self.delay )
400 else:
400 else:
401 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
401 print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
402
402
403 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
403 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
404 if file:
404 if file:
405 if self.__verifyFile(file):
405 if self.__verifyFile(file):
406 fileOk_flag = True
406 fileOk_flag = True
407 break
407 break
408
408
409 if fileOk_flag:
409 if fileOk_flag:
410 break
410 break
411
411
412 firstTime_flag = False
412 firstTime_flag = False
413
413
414 print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
414 print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
415 self.set += 1
415 self.set += 1
416
416
417 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
417 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
418 self.set = 0
418 self.set = 0
419 self.doy += 1
419 self.doy += 1
420
420
421 if fileOk_flag:
421 if fileOk_flag:
422 self.fileSize = os.path.getsize( file )
422 self.fileSize = os.path.getsize( file )
423 self.filename = file
423 self.filename = file
424 self.flagIsNewFile = 1
424 self.flagIsNewFile = 1
425 if self.fp != None: self.fp.close()
425 if self.fp != None: self.fp.close()
426 self.fp = open(file)
426 self.fp = open(file)
427 self.flagNoMoreFiles = 0
427 self.flagNoMoreFiles = 0
428 print 'Setting the file: %s' % file
428 print 'Setting the file: %s' % file
429 else:
429 else:
430 self.fileSize = 0
430 self.fileSize = 0
431 self.filename = None
431 self.filename = None
432 self.flagIsNewFile = 0
432 self.flagIsNewFile = 0
433 self.fp = None
433 self.fp = None
434 self.flagNoMoreFiles = 1
434 self.flagNoMoreFiles = 1
435 print 'No more Files'
435 print 'No more Files'
436
436
437 return fileOk_flag
437 return fileOk_flag
438
438
439
439
440 def __setNextFileOffline(self):
440 def __setNextFileOffline(self):
441 """
441 """
442 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
442 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
443
443
444 Affected:
444 Affected:
445 self.flagIsNewFile
445 self.flagIsNewFile
446 self.fileIndex
446 self.fileIndex
447 self.filename
447 self.filename
448 self.fileSize
448 self.fileSize
449 self.fp
449 self.fp
450
450
451 Return:
451 Return:
452 0 : si un determinado file no puede ser abierto
452 0 : si un determinado file no puede ser abierto
453 1 : si el file fue abierto con exito
453 1 : si el file fue abierto con exito
454
454
455 Excepciones:
455 Excepciones:
456 Si un determinado file no puede ser abierto
456 Si un determinado file no puede ser abierto
457 """
457 """
458 idFile = self.fileIndex
458 idFile = self.fileIndex
459 while(True):
459 while(True):
460
460
461 idFile += 1
461 idFile += 1
462
462
463 if not(idFile < len(self.filenameList)):
463 if not(idFile < len(self.filenameList)):
464 self.flagNoMoreFiles = 1
464 self.flagNoMoreFiles = 1
465 print 'No more Files'
465 print 'No more Files'
466 return 0
466 return 0
467
467
468 filename = self.filenameList[idFile]
468 filename = self.filenameList[idFile]
469 fileSize = os.path.getsize(filename)
469 fileSize = os.path.getsize(filename)
470
470
471 try:
471 try:
472 fp = open(filename,'rb')
472 fp = open(filename,'rb')
473 except:
473 except:
474 raise IOError, "The file %s can't be opened" %filename
474 raise IOError, "The file %s can't be opened" %filename
475
475
476 currentSize = fileSize - fp.tell()
476 currentSize = fileSize - fp.tell()
477 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
477 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
478
478
479 if (currentSize < neededSize):
479 if (currentSize < neededSize):
480 print "Skipping the file %s due to it hasn't enough data" %filename
480 print "Skipping the file %s due to it hasn't enough data" %filename
481 continue
481 continue
482
482
483 break
483 break
484
484
485 self.flagIsNewFile = 1
485 self.flagIsNewFile = 1
486 self.fileIndex = idFile
486 self.fileIndex = idFile
487 self.filename = filename
487 self.filename = filename
488 self.fileSize = fileSize
488 self.fileSize = fileSize
489 self.fp = fp
489 self.fp = fp
490
490
491 print 'Setting the file: %s'%self.filename
491 print 'Setting the file: %s'%self.filename
492
492
493 return 1
493 return 1
494
494
495
495
496 def setNextFile(self):
496 def setNextFile(self):
497 """
497 """
498 Determina el siguiente file a leer y si hay uno disponible lee el First Header
498 Determina el siguiente file a leer y si hay uno disponible lee el First Header
499
499
500 Affected:
500 Affected:
501 self.m_BasicHeader
501 self.m_BasicHeader
502 self.m_SystemHeader
502 self.m_SystemHeader
503 self.m_RadarControllerHeader
503 self.m_RadarControllerHeader
504 self.m_ProcessingHeader
504 self.m_ProcessingHeader
505 self.firstHeaderSize
505 self.firstHeaderSize
506
506
507 Return:
507 Return:
508 0 : Si no hay files disponibles
508 0 : Si no hay files disponibles
509 1 : Si hay mas files disponibles
509 1 : Si hay mas files disponibles
510 """
510 """
511 if self.fp != None:
511 if self.fp != None:
512 self.fp.close()
512 self.fp.close()
513
513
514 if self.online:
514 if self.online:
515 newFile = self.__setNextFileOnline()
515 newFile = self.__setNextFileOnline()
516 else:
516 else:
517 newFile = self.__setNextFileOffline()
517 newFile = self.__setNextFileOffline()
518
518
519 if self.flagNoMoreFiles:
519 if self.flagNoMoreFiles:
520 sys.exit(0)
520 sys.exit(0)
521
521
522 if not(newFile):
522 if not(newFile):
523 return 0
523 return 0
524
524
525 self.__readFirstHeader()
525 self.__readFirstHeader()
526 self.nBlocks = 0
526 self.nBlocks = 0
527 return 1
527 return 1
528
528
529
529
530 def __setNewBlock(self):
530 def __setNewBlock(self):
531 """
531 """
532 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
532 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
533
533
534 Affected:
534 Affected:
535 self.m_BasicHeader
535 self.m_BasicHeader
536 self.flagNoContinuousBlock
536 self.flagNoContinuousBlock
537 self.ns
537 self.ns
538
538
539 Return:
539 Return:
540 0 : Si el file no tiene un Basic Header que pueda ser leido
540 0 : Si el file no tiene un Basic Header que pueda ser leido
541 1 : Si se pudo leer el Basic Header
541 1 : Si se pudo leer el Basic Header
542 """
542 """
543 if self.fp == None:
543 if self.fp == None:
544 return 0
544 return 0
545
545
546 if self.flagIsNewFile:
546 if self.flagIsNewFile:
547 return 1
547 return 1
548
548
549 currentSize = self.fileSize - self.fp.tell()
549 currentSize = self.fileSize - self.fp.tell()
550 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
550 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
551
551
552 #If there is enough data setting new data block
552 #If there is enough data setting new data block
553 if ( currentSize >= neededSize ):
553 if ( currentSize >= neededSize ):
554 self.__rdBasicHeader()
554 self.__rdBasicHeader()
555 return 1
555 return 1
556
556
557 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
557 #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:
558 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
559 for nTries in range( self.nTries ):
559 for nTries in range( self.nTries ):
560
560
561 fpointer = self.fp.tell()
561 fpointer = self.fp.tell()
562 self.fp.close()
562 self.fp.close()
563
563
564 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
564 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
565 time.sleep( self.delay )
565 time.sleep( self.delay )
566
566
567 self.fp = open( self.filename, 'rb' )
567 self.fp = open( self.filename, 'rb' )
568 self.fp.seek( fpointer )
568 self.fp.seek( fpointer )
569
569
570 self.fileSize = os.path.getsize( self.filename )
570 self.fileSize = os.path.getsize( self.filename )
571 currentSize = self.fileSize - self.fp.tell()
571 currentSize = self.fileSize - self.fp.tell()
572 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
572 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
573
573
574 if ( currentSize >= neededSize ):
574 if ( currentSize >= neededSize ):
575 self.__rdBasicHeader()
575 self.__rdBasicHeader()
576 return 1
576 return 1
577
577
578 #Setting new file
578 #Setting new file
579 if not( self.setNextFile() ):
579 if not( self.setNextFile() ):
580 return 0
580 return 0
581
581
582 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
582 deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
583
583
584 self.flagResetProcessing = 0
584 self.flagResetProcessing = 0
585
585
586 if deltaTime > self.maxTimeStep:
586 if deltaTime > self.maxTimeStep:
587 self.flagResetProcessing = 1
587 self.flagResetProcessing = 1
588 #self.nReadBlocks = 0
588 #self.nReadBlocks = 0
589
589
590 return 1
590 return 1
591
591
592
592
593 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
593 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
594 """
594 """
595 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
595 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
596 devuelve el archivo encontrado ademas de otros datos.
596 devuelve el archivo encontrado ademas de otros datos.
597
597
598 Input:
598 Input:
599 path : carpeta donde estan contenidos los files que contiene data
599 path : carpeta donde estan contenidos los files que contiene data
600 startDateTime : punto especifico en el tiempo del cual se requiere la data
600 startDateTime : punto especifico en el tiempo del cual se requiere la data
601 ext : extension de los files
601 ext : extension de los files
602
602
603 Return:
603 Return:
604 year : el anho
604 year : el anho
605 doy : el numero de dia del anho
605 doy : el numero de dia del anho
606 set : el set del archivo
606 set : el set del archivo
607 filename : el ultimo file de una determinada carpeta
607 filename : el ultimo file de una determinada carpeta
608 directory : eL directorio donde esta el file encontrado
608 directory : eL directorio donde esta el file encontrado
609 """
609 """
610 dirList = []
610 dirList = []
611 pathList = []
611 pathList = []
612 directory = None
612 directory = None
613
613
614 for thisPath in os.listdir(path):
614 for thisPath in os.listdir(path):
615 if os.path.isdir(os.path.join(path,thisPath)):
615 if os.path.isdir(os.path.join(path,thisPath)):
616 dirList.append(thisPath)
616 dirList.append(thisPath)
617
617
618 if not(dirList):
618 if not(dirList):
619 return None, None, None, None, None
619 return None, None, None, None, None
620
620
621 dirList = sorted( dirList, key=str.lower )
621 dirList = sorted( dirList, key=str.lower )
622
622
623 if startDateTime:
623 if startDateTime:
624 thisDateTime = startDateTime
624 thisDateTime = startDateTime
625 if endDateTime == None: endDateTime = startDateTime
625 if endDateTime == None: endDateTime = startDateTime
626
626
627 while(thisDateTime <= endDateTime):
627 while(thisDateTime <= endDateTime):
628 year = thisDateTime.timetuple().tm_year
628 year = thisDateTime.timetuple().tm_year
629 doy = thisDateTime.timetuple().tm_yday
629 doy = thisDateTime.timetuple().tm_yday
630
630
631 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
631 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
632 if len(match) == 0:
632 if len(match) == 0:
633 thisDateTime += datetime.timedelta(1)
633 thisDateTime += datetime.timedelta(1)
634 continue
634 continue
635
635
636 pathList.append(os.path.join(path,match[0], expLabel))
636 pathList.append(os.path.join(path,match[0], expLabel))
637 thisDateTime += datetime.timedelta(1)
637 thisDateTime += datetime.timedelta(1)
638
638
639 if not(pathList):
639 if not(pathList):
640 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
640 print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
641 return None, None, None, None, None
641 return None, None, None, None, None
642
642
643 directory = pathList[0]
643 directory = pathList[0]
644
644
645 else:
645 else:
646 directory = dirList[-1]
646 directory = dirList[-1]
647 directory = os.path.join(path,directory)
647 directory = os.path.join(path,directory)
648
648
649 filename = getlastFileFromPath(directory, ext)
649 filename = getlastFileFromPath(directory, ext)
650
650
651 if not(filename):
651 if not(filename):
652 return None, None, None, None, None
652 return None, None, None, None, None
653
653
654 if not(self.__verifyFile(os.path.join(directory, filename))):
654 if not(self.__verifyFile(os.path.join(directory, filename))):
655 return None, None, None, None, None
655 return None, None, None, None, None
656
656
657 year = int( filename[1:5] )
657 year = int( filename[1:5] )
658 doy = int( filename[5:8] )
658 doy = int( filename[5:8] )
659 set = int( filename[8:11] )
659 set = int( filename[8:11] )
660
660
661 return directory, filename, year, doy, set
661 return directory, filename, year, doy, set
662
662
663
663
664 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
664 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
665 """
665 """
666 Realiza una busqueda de los archivos que coincidan con los parametros
666 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
667 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
668 correcta la estructura de directorios debe ser la siguiente:
668 correcta la estructura de directorios debe ser la siguiente:
669
669
670 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
670 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
671
671
672 [yyyy]: anio
672 [yyyy]: anio
673 [ddd] : dia del anio
673 [ddd] : dia del anio
674 [sss] : set del archivo
674 [sss] : set del archivo
675
675
676 Inputs:
676 Inputs:
677 path : Directorio de datos donde se realizara la busqueda. Todos los
677 path : Directorio de datos donde se realizara la busqueda. Todos los
678 ficheros que concidan con el criterio de busqueda seran
678 ficheros que concidan con el criterio de busqueda seran
679 almacenados en una lista y luego retornados.
679 almacenados en una lista y luego retornados.
680 startDateTime : Fecha inicial. Rechaza todos los archivos donde
680 startDateTime : Fecha inicial. Rechaza todos los archivos donde
681 file end time < startDateTime (obejto datetime.datetime)
681 file end time < startDateTime (obejto datetime.datetime)
682
682
683 endDateTime : Fecha final. Rechaza todos los archivos donde
683 endDateTime : Fecha final. Rechaza todos los archivos donde
684 file start time > endDateTime (obejto datetime.datetime)
684 file start time > endDateTime (obejto datetime.datetime)
685
685
686 set : Set del primer archivo a leer. Por defecto None
686 set : Set del primer archivo a leer. Por defecto None
687
687
688 expLabel : Nombre del subdirectorio de datos. Por defecto ""
688 expLabel : Nombre del subdirectorio de datos. Por defecto ""
689
689
690 ext : Extension de los archivos a leer. Por defecto .r
690 ext : Extension de los archivos a leer. Por defecto .r
691
691
692 Return:
692 Return:
693
693
694 (pathList, filenameList)
694 (pathList, filenameList)
695
695
696 pathList : Lista de directorios donde se encontraron archivos dentro
696 pathList : Lista de directorios donde se encontraron archivos dentro
697 de los parametros especificados
697 de los parametros especificados
698 filenameList : Lista de archivos (ruta completa) que coincidieron con los
698 filenameList : Lista de archivos (ruta completa) que coincidieron con los
699 parametros especificados.
699 parametros especificados.
700
700
701 Variables afectadas:
701 Variables afectadas:
702
702
703 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
703 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
704 como fuente para leer los bloque de datos, si se termina
704 como fuente para leer los bloque de datos, si se termina
705 de leer todos los bloques de datos de un determinado
705 de leer todos los bloques de datos de un determinado
706 archivo se pasa al siguiente archivo de la lista.
706 archivo se pasa al siguiente archivo de la lista.
707
707
708 Excepciones:
708 Excepciones:
709
709
710 """
710 """
711
711
712 print "Searching files ..."
712 print "Searching files ..."
713
713
714 dirList = []
714 dirList = []
715 for thisPath in os.listdir(path):
715 for thisPath in os.listdir(path):
716 if os.path.isdir(os.path.join(path,thisPath)):
716 if os.path.isdir(os.path.join(path,thisPath)):
717 dirList.append(thisPath)
717 dirList.append(thisPath)
718
718
719 if not(dirList):
719 if not(dirList):
720 return None, None
720 return None, None
721
721
722 pathList = []
722 pathList = []
723
723
724 thisDateTime = startDateTime
724 thisDateTime = startDateTime
725
725
726 while(thisDateTime <= endDateTime):
726 while(thisDateTime <= endDateTime):
727 year = thisDateTime.timetuple().tm_year
727 year = thisDateTime.timetuple().tm_year
728 doy = thisDateTime.timetuple().tm_yday
728 doy = thisDateTime.timetuple().tm_yday
729
729
730 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
730 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
731 if len(match) == 0:
731 if len(match) == 0:
732 thisDateTime += datetime.timedelta(1)
732 thisDateTime += datetime.timedelta(1)
733 continue
733 continue
734
734
735 pathList.append(os.path.join(path,match[0],expLabel))
735 pathList.append(os.path.join(path,match[0],expLabel))
736 thisDateTime += datetime.timedelta(1)
736 thisDateTime += datetime.timedelta(1)
737
737
738 startUtSeconds = time.mktime(startDateTime.timetuple())
738 startUtSeconds = time.mktime(startDateTime.timetuple())
739 endUtSeconds = time.mktime(endDateTime.timetuple())
739 endUtSeconds = time.mktime(endDateTime.timetuple())
740
740
741 filenameList = []
741 filenameList = []
742 for thisPath in pathList:
742 for thisPath in pathList:
743 fileList = glob.glob1(thisPath, "*%s" %ext)
743 fileList = glob.glob1(thisPath, "*%s" %ext)
744 fileList.sort()
744 fileList.sort()
745 for file in fileList:
745 for file in fileList:
746 filename = os.path.join(thisPath,file)
746 filename = os.path.join(thisPath,file)
747 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
747 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
748 filenameList.append(filename)
748 filenameList.append(filename)
749
749
750 if not(filenameList):
750 if not(filenameList):
751 return None, None
751 return None, None
752
752
753 self.filenameList = filenameList
753 self.filenameList = filenameList
754
754
755 return pathList, filenameList
755 return pathList, filenameList
756
756
757
757
758 def __verifyFile(self, filename, msgFlag=True):
758 def __verifyFile(self, filename, msgFlag=True):
759 """
759 """
760 Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
760 Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
761
761
762 Return:
762 Return:
763 0 : file no valido para ser leido
763 0 : file no valido para ser leido
764 1 : file valido para ser leido
764 1 : file valido para ser leido
765 """
765 """
766 m_BasicHeader = BasicHeader()
766 m_BasicHeader = BasicHeader()
767 m_SystemHeader = SystemHeader()
767 m_SystemHeader = SystemHeader()
768 m_RadarControllerHeader = RadarControllerHeader()
768 m_RadarControllerHeader = RadarControllerHeader()
769 m_ProcessingHeader = ProcessingHeader()
769 m_ProcessingHeader = ProcessingHeader()
770 flagFileOK = False
770 flagFileOK = False
771
771
772 try:
772 try:
773 fp = open( filename,'rb' ) #lectura binaria
773 fp = open( filename,'rb' ) #lectura binaria
774 except:
774 except:
775 if msgFlag:
775 if msgFlag:
776 print "The file %s can't be opened" % (filename)
776 print "The file %s can't be opened" % (filename)
777
777
778 try:
778 try:
779 if not( m_BasicHeader.read(fp) ): raise ValueError
779 if not( m_BasicHeader.read(fp) ): raise ValueError
780 if not( m_SystemHeader.read(fp) ): raise ValueError
780 if not( m_SystemHeader.read(fp) ): raise ValueError
781 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
781 if not( m_RadarControllerHeader.read(fp) ): raise ValueError
782 if not( m_ProcessingHeader.read(fp) ): raise ValueError
782 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))
783 data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
784 if m_BasicHeader.size > self.basicHeaderSize:
784 if m_BasicHeader.size > self.basicHeaderSize:
785 flagFileOK = True
785 flagFileOK = True
786 except:
786 except:
787 if msgFlag:
787 if msgFlag:
788 print "\tThe file %s is empty or it hasn't enough data" % filename
788 print "\tThe file %s is empty or it hasn't enough data" % filename
789
789
790 fp.close()
790 fp.close()
791
791
792 if not(flagFileOK):
792 if not(flagFileOK):
793 return 0
793 return 0
794
794
795 return 1
795 return 1
796
796
797
797
798 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
798 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
799 """
799 """
800 setup configura los parametros de lectura de la clase DataReader.
800 setup configura los parametros de lectura de la clase DataReader.
801
801
802 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
802 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
803 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
804 self.filenameList.
804 self.filenameList.
805
805
806 Input:
806 Input:
807 path : Directorios donde se ubican los datos a leer. Dentro de este
807 path : Directorios donde se ubican los datos a leer. Dentro de este
808 directorio deberia de estar subdirectorios de la forma:
808 directorio deberia de estar subdirectorios de la forma:
809
809
810 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
810 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
811
811
812 startDateTime : Fecha inicial. Rechaza todos los archivos donde
812 startDateTime : Fecha inicial. Rechaza todos los archivos donde
813 file end time < startDatetime (obejto datetime.datetime)
813 file end time < startDatetime (obejto datetime.datetime)
814
814
815 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
815 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
816 file end time < startDatetime (obejto datetime.datetime)
816 file end time < startDatetime (obejto datetime.datetime)
817
817
818 set : Set del primer archivo a leer. Por defecto None
818 set : Set del primer archivo a leer. Por defecto None
819
819
820 expLabel : Nombre del subdirectorio de datos. Por defecto ""
820 expLabel : Nombre del subdirectorio de datos. Por defecto ""
821
821
822 ext : Extension de los archivos a leer. Por defecto .r
822 ext : Extension de los archivos a leer. Por defecto .r
823
823
824 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
824 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
825
825
826 Return:
826 Return:
827 0 : Si no encuentra files que cumplan con las condiciones dadas
827 0 : Si no encuentra files que cumplan con las condiciones dadas
828 1 : Si encuentra files que cumplan con las condiciones dadas
828 1 : Si encuentra files que cumplan con las condiciones dadas
829
829
830 Affected:
830 Affected:
831 self.startUTCSeconds
831 self.startUTCSeconds
832 self.endUTCSeconds
832 self.endUTCSeconds
833 self.startYear
833 self.startYear
834 self.endYear
834 self.endYear
835 self.startDoy
835 self.startDoy
836 self.endDoy
836 self.endDoy
837 self.pathList
837 self.pathList
838 self.filenameList
838 self.filenameList
839 self.online
839 self.online
840 """
840 """
841
841
842 if ext == None:
842 if ext == None:
843 ext = self.ext
843 ext = self.ext
844
844
845 if online:
845 if online:
846 print "Searching files ..."
846 print "Searching files ..."
847 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
847 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
848
848
849 if not(doypath):
849 if not(doypath):
850 for nTries in range( self.nTries ):
850 for nTries in range( self.nTries ):
851 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
851 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
852 time.sleep( self.delay )
852 time.sleep( self.delay )
853 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
853 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
854 if doypath:
854 if doypath:
855 break
855 break
856
856
857 if not(doypath):
857 if not(doypath):
858 print "There 'isn't valied files in %s" % path
858 print "There 'isn't valied files in %s" % path
859 return 0
859 return 0
860
860
861 self.year = year
861 self.year = year
862 self.doy = doy
862 self.doy = doy
863 self.set = set - 1
863 self.set = set - 1
864 self.path = path
864 self.path = path
865
865
866 else: # offline
866 else: # offline
867 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
867 pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
868 if not(pathList):
868 if not(pathList):
869 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
869 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
870 return 0
870 return 0
871
871
872 self.fileIndex = -1
872 self.fileIndex = -1
873 self.pathList = pathList
873 self.pathList = pathList
874 self.filenameList = filenameList
874 self.filenameList = filenameList
875
875
876 self.online = online
876 self.online = online
877 self.ext = ext
877 self.ext = ext
878
878
879 ext = ext.lower()
879 ext = ext.lower()
880
880
881 if not( self.setNextFile() ):
881 if not( self.setNextFile() ):
882 if (startDateTime != None) and (endDateTime != None):
882 if (startDateTime != None) and (endDateTime != None):
883 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
883 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
884 elif startDateTime != None:
884 elif startDateTime != None:
885 print "No files in : %s" % startDateTime.ctime()
885 print "No files in : %s" % startDateTime.ctime()
886 else:
886 else:
887 print "No files"
887 print "No files"
888 return 0
888 return 0
889
889
890 if startDateTime != None:
890 if startDateTime != None:
891 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
891 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
892 self.startYear = startDateTime.timetuple().tm_year
892 self.startYear = startDateTime.timetuple().tm_year
893 self.startDoy = startDateTime.timetuple().tm_yday
893 self.startDoy = startDateTime.timetuple().tm_yday
894
894
895 if endDateTime != None:
895 if endDateTime != None:
896 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
896 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
897 self.endYear = endDateTime.timetuple().tm_year
897 self.endYear = endDateTime.timetuple().tm_year
898 self.endDoy = endDateTime.timetuple().tm_yday
898 self.endDoy = endDateTime.timetuple().tm_yday
899 #call fillHeaderValues() - to Data Object
899 #call fillHeaderValues() - to Data Object
900
900
901 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
901 self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
902 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
902 self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
903 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
903 self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
904 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
904 self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
905 self.m_DataObj.dataType = self.dataType
905 self.m_DataObj.dataType = self.dataType
906
906
907 return 1
907 return 1
908
908
909
909
910 def readNextBlock(self):
910 def readNextBlock(self):
911 """
911 """
912 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
912 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.
913 mas bloques disponibles en el archivo actual salta al siguiente.
914
914
915 Affected:
915 Affected:
916 self.lastUTTime
916 self.lastUTTime
917
917
918 Return: None
918 Return: None
919 """
919 """
920 if not(self.__setNewBlock()):
920 if not(self.__setNewBlock()):
921 return 0
921 return 0
922
922
923 if not(self.readBlock()):
923 if not(self.readBlock()):
924 return 0
924 return 0
925
925
926 self.lastUTTime = self.m_BasicHeader.utc
926 self.lastUTTime = self.m_BasicHeader.utc
927
927
928 return 1
928 return 1
929
929
930
930
931 class JRODataWriter(DataWriter):
931 class JRODataWriter(DataWriter):
932
932
933 """
933 """
934 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
934 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
935 de los datos siempre se realiza por bloques.
935 de los datos siempre se realiza por bloques.
936 """
936 """
937
937
938 fp = None
938 fp = None
939
939
940 blocksCounter = 0
940 blocksCounter = 0
941
941
942 flagIsNewFile = 1
942 flagIsNewFile = 1
943
943
944 nWriteBlocks = 0
944 nWriteBlocks = 0
945
945
946 flagIsNewBlock = 0
946 flagIsNewBlock = 0
947
947
948 flagNoMoreFiles = 0
948 flagNoMoreFiles = 0
949
949
950
950
951 def __writeFirstHeader(self):
951 def __writeFirstHeader(self):
952 """
952 """
953 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
953 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
954
954
955 Affected:
955 Affected:
956 __dataType
956 __dataType
957
957
958 Return:
958 Return:
959 None
959 None
960 """
960 """
961 self.__writeBasicHeader()
961 self.__writeBasicHeader()
962 self.__wrSystemHeader()
962 self.__wrSystemHeader()
963 self.__wrRadarControllerHeader()
963 self.__wrRadarControllerHeader()
964 self.__wrProcessingHeader()
964 self.__wrProcessingHeader()
965 self.dataType = self.m_DataObj.dataType
965 self.dataType = self.m_DataObj.dataType
966
966
967
967
968 def __writeBasicHeader(self, fp=None):
968 def __writeBasicHeader(self, fp=None):
969 """
969 """
970 Escribe solo el Basic header en el file creado
970 Escribe solo el Basic header en el file creado
971
971
972 Return:
972 Return:
973 None
973 None
974 """
974 """
975 if fp == None:
975 if fp == None:
976 fp = self.fp
976 fp = self.fp
977
977
978 self.m_DataObj.m_BasicHeader.write(fp)
978 self.m_DataObj.m_BasicHeader.write(fp)
979
979
980
980
981 def __wrSystemHeader(self, fp=None):
981 def __wrSystemHeader(self, fp=None):
982 """
982 """
983 Escribe solo el System header en el file creado
983 Escribe solo el System header en el file creado
984
984
985 Return:
985 Return:
986 None
986 None
987 """
987 """
988 if fp == None:
988 if fp == None:
989 fp = self.fp
989 fp = self.fp
990
990
991 self.m_DataObj.m_SystemHeader.write(fp)
991 self.m_DataObj.m_SystemHeader.write(fp)
992
992
993
993
994 def __wrRadarControllerHeader(self, fp=None):
994 def __wrRadarControllerHeader(self, fp=None):
995 """
995 """
996 Escribe solo el RadarController header en el file creado
996 Escribe solo el RadarController header en el file creado
997
997
998 Return:
998 Return:
999 None
999 None
1000 """
1000 """
1001 if fp == None:
1001 if fp == None:
1002 fp = self.fp
1002 fp = self.fp
1003
1003
1004 self.m_DataObj.m_RadarControllerHeader.write(fp)
1004 self.m_DataObj.m_RadarControllerHeader.write(fp)
1005
1005
1006
1006
1007 def __wrProcessingHeader(self, fp=None):
1007 def __wrProcessingHeader(self, fp=None):
1008 """
1008 """
1009 Escribe solo el Processing header en el file creado
1009 Escribe solo el Processing header en el file creado
1010
1010
1011 Return:
1011 Return:
1012 None
1012 None
1013 """
1013 """
1014 if fp == None:
1014 if fp == None:
1015 fp = self.fp
1015 fp = self.fp
1016
1016
1017 self.m_DataObj.m_ProcessingHeader.write(fp)
1017 self.m_DataObj.m_ProcessingHeader.write(fp)
1018
1018
1019
1019
1020 def setNextFile(self):
1020 def setNextFile(self):
1021 """
1021 """
1022 Determina el siguiente file que sera escrito
1022 Determina el siguiente file que sera escrito
1023
1023
1024 Affected:
1024 Affected:
1025 self.filename
1025 self.filename
1026 self.subfolder
1026 self.subfolder
1027 self.fp
1027 self.fp
1028 self.setFile
1028 self.setFile
1029 self.flagIsNewFile
1029 self.flagIsNewFile
1030
1030
1031 Return:
1031 Return:
1032 0 : Si el archivo no puede ser escrito
1032 0 : Si el archivo no puede ser escrito
1033 1 : Si el archivo esta listo para ser escrito
1033 1 : Si el archivo esta listo para ser escrito
1034 """
1034 """
1035 ext = self.ext
1035 ext = self.ext
1036 path = self.path
1036 path = self.path
1037
1037
1038 if self.fp != None:
1038 if self.fp != None:
1039 self.fp.close()
1039 self.fp.close()
1040
1040
1041 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1041 timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
1042 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1042 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1043
1043
1044 tmp = os.path.join( path, subfolder )
1044 tmp = os.path.join( path, subfolder )
1045 if not( os.path.exists(tmp) ):
1045 if not( os.path.exists(tmp) ):
1046 os.mkdir(tmp)
1046 os.mkdir(tmp)
1047 self.setFile = -1 #inicializo mi contador de seteo
1047 self.setFile = -1 #inicializo mi contador de seteo
1048 else:
1048 else:
1049 filesList = os.listdir( tmp )
1049 filesList = os.listdir( tmp )
1050 if len( filesList ) > 0:
1050 if len( filesList ) > 0:
1051 filesList = sorted( filesList, key=str.lower )
1051 filesList = sorted( filesList, key=str.lower )
1052 filen = filesList[-1]
1052 filen = filesList[-1]
1053 # el filename debera tener el siguiente formato
1053 # el filename debera tener el siguiente formato
1054 # 0 1234 567 89A BCDE (hex)
1054 # 0 1234 567 89A BCDE (hex)
1055 # x YYYY DDD SSS .ext
1055 # x YYYY DDD SSS .ext
1056 if isNumber( filen[8:11] ):
1056 if isNumber( filen[8:11] ):
1057 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1057 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1058 else:
1058 else:
1059 self.setFile = -1
1059 self.setFile = -1
1060 else:
1060 else:
1061 self.setFile = -1 #inicializo mi contador de seteo
1061 self.setFile = -1 #inicializo mi contador de seteo
1062
1062
1063 setFile = self.setFile
1063 setFile = self.setFile
1064 setFile += 1
1064 setFile += 1
1065
1065
1066 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1066 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1067 timeTuple.tm_year,
1067 timeTuple.tm_year,
1068 timeTuple.tm_yday,
1068 timeTuple.tm_yday,
1069 setFile,
1069 setFile,
1070 ext )
1070 ext )
1071
1071
1072 filename = os.path.join( path, subfolder, file )
1072 filename = os.path.join( path, subfolder, file )
1073
1073
1074 fp = open( filename,'wb' )
1074 fp = open( filename,'wb' )
1075
1075
1076 self.blocksCounter = 0
1076 self.blocksCounter = 0
1077
1077
1078 #guardando atributos
1078 #guardando atributos
1079 self.filename = filename
1079 self.filename = filename
1080 self.subfolder = subfolder
1080 self.subfolder = subfolder
1081 self.fp = fp
1081 self.fp = fp
1082 self.setFile = setFile
1082 self.setFile = setFile
1083 self.flagIsNewFile = 1
1083 self.flagIsNewFile = 1
1084
1084
1085 print 'Writing the file: %s'%self.filename
1085 print 'Writing the file: %s'%self.filename
1086
1086
1087 self.__writeFirstHeader()
1087 self.__writeFirstHeader()
1088
1088
1089 return 1
1089 return 1
1090
1090
1091
1091
1092 def __setNewBlock(self):
1092 def __setNewBlock(self):
1093 """
1093 """
1094 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1094 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1095
1095
1096 Return:
1096 Return:
1097 0 : si no pudo escribir nada
1097 0 : si no pudo escribir nada
1098 1 : Si escribio el Basic el First Header
1098 1 : Si escribio el Basic el First Header
1099 """
1099 """
1100 if self.fp == None:
1100 if self.fp == None:
1101 self.setNextFile()
1101 self.setNextFile()
1102
1102
1103 if self.flagIsNewFile:
1103 if self.flagIsNewFile:
1104 return 1
1104 return 1
1105
1105
1106 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1106 if self.blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1107 self.__writeBasicHeader()
1107 self.__writeBasicHeader()
1108 return 1
1108 return 1
1109
1109
1110 if not( self.setNextFile() ):
1110 if not( self.setNextFile() ):
1111 return 0
1111 return 0
1112
1112
1113 return 1
1113 return 1
1114
1114
1115
1115
1116 def writeNextBlock(self):
1116 def writeNextBlock(self):
1117 """
1117 """
1118 Selecciona el bloque siguiente de datos y los escribe en un file
1118 Selecciona el bloque siguiente de datos y los escribe en un file
1119
1119
1120 Return:
1120 Return:
1121 0 : Si no hizo pudo escribir el bloque de datos
1121 0 : Si no hizo pudo escribir el bloque de datos
1122 1 : Si no pudo escribir el bloque de datos
1122 1 : Si no pudo escribir el bloque de datos
1123 """
1123 """
1124 if not( self.__setNewBlock() ):
1124 if not( self.__setNewBlock() ):
1125 return 0
1125 return 0
1126
1126
1127 self.writeBlock()
1127 self.writeBlock()
1128
1128
1129 return 1
1129 return 1
1130
1130
1131
1131
1132 def getHeader(self):
1132 def getHeader(self):
1133 """
1133 """
1134 Obtiene una copia del First Header
1134 Obtiene una copia del First Header
1135
1135
1136 Affected:
1136 Affected:
1137 self.m_BasicHeader
1137 self.m_BasicHeader
1138 self.m_SystemHeader
1138 self.m_SystemHeader
1139 self.m_RadarControllerHeader
1139 self.m_RadarControllerHeader
1140 self.m_ProcessingHeader
1140 self.m_ProcessingHeader
1141 self.dataType
1141 self.dataType
1142
1142
1143 Return:
1143 Return:
1144 None
1144 None
1145 """
1145 """
1146 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1146 self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
1147 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1147 self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
1148 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1148 self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
1149 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1149 self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
1150 self.dataType = self.m_DataObj.dataType
1150 self.dataType = self.m_DataObj.dataType
1151
1151
1152
1152
1153 def setup(self, path, set=0, ext=None):
1153 def setup(self, path, set=0, ext=None):
1154 """
1154 """
1155 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1155 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1156
1156
1157 Inputs:
1157 Inputs:
1158 path : el path destino en el cual se escribiran los files a crear
1158 path : el path destino en el cual se escribiran los files a crear
1159 format : formato en el cual sera salvado un file
1159 format : formato en el cual sera salvado un file
1160 set : el setebo del file
1160 set : el setebo del file
1161
1161
1162 Return:
1162 Return:
1163 0 : Si no realizo un buen seteo
1163 0 : Si no realizo un buen seteo
1164 1 : Si realizo un buen seteo
1164 1 : Si realizo un buen seteo
1165 """
1165 """
1166
1166
1167 if ext == None:
1167 if ext == None:
1168 ext = self.ext
1168 ext = self.ext
1169
1169
1170 ext = ext.lower()
1170 ext = ext.lower()
1171
1171
1172 self.path = path
1172 self.path = path
1173 self.setFile = set - 1
1173 self.setFile = set - 1
1174 self.ext = ext
1174 self.ext = ext
1175 #self.format = format
1175 #self.format = format
1176 self.getHeader()
1176 self.getHeader()
1177
1177
1178 self.setBlockDimension()
1178 self.setBlockDimension()
1179
1179
1180 if not( self.setNextFile() ):
1180 if not( self.setNextFile() ):
1181 print "There isn't a next file"
1181 print "There isn't a next file"
1182 return 0
1182 return 0
1183
1183
1184 return 1
1184 return 1
General Comments 0
You need to be logged in to leave comments. Login now