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