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