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