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