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