##// END OF EJS Templates
schain-jc
RSS
VOTAJEIO.py:...
Victor Sarmiento -
r46:f6891cff9cbe
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1566 +1,1634
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 '''
6 '''
7
7
8 import os, sys
8 import os, sys
9 import numpy
9 import numpy
10 import glob
10 import glob
11 import fnmatch
11 import fnmatch
12 import time, datetime
12 import time, datetime
13
13
14 path = os.path.split(os.getcwd())[0]
14 path = os.path.split(os.getcwd())[0]
15 sys.path.append(path)
15 sys.path.append(path)
16
16
17 from IO.HeaderIO import *
17 from IO.HeaderIO import *
18 from IO.DataIO import DataReader
18 from IO.DataIO import DataReader
19 from IO.DataIO import DataWriter
19 from IO.DataIO import DataWriter
20
20
21 from Model.Voltage import Voltage
21 from Model.Voltage import Voltage
22
22
23
23
24 def getlastFileFromPath( pathList, ext ):
24 def isFileOK(filename):
25 """
26 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
27 si no seria un archivo invalido
28
29 Return:
30 True : si es un archivo valido
31 False : si no es un archivo valido
32
33 Exceptions:
34 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
35 una exception
36 """
37 m_BasicHeader = BasicHeader()
38 m_ProcessingHeader = ProcessingHeader()
39 m_RadarControllerHeader = RadarControllerHeader()
40 m_SystemHeader = SystemHeader()
41 fp = None
42
43 try:
44 fp = open( filename,'rb' ) #lectura binaria
45 m_BasicHeader.read(fp)
46 m_SystemHeader.read(fp)
47 m_RadarControllerHeader.read(fp)
48 m_ProcessingHeader.read(fp)
49 fp.close()
50 except:
51 if fp != None: fp.close()
52 return False
53
54 return True
55
56
57 def getlastFileFromPath(pathList,ext):
25 """
58 """
26 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
59 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
27 al final de la depuracion devuelve el ultimo file de la lista que quedo.
60 al final de la depuracion devuelve el ultimo file de la lista que quedo.
28
61
29 Input:
62 Input:
30 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
63 pathList : lista conteniendo todos los filename completos que componen una determinada carpeta
31 ext : extension de los files contenidos en una carpeta
64 ext : extension de los files contenidos en una carpeta
32
65
33 Return:
66 Return:
34 El ultimo file de una determinada carpeta
67 El ultimo file de una determinada carpeta
35 """
68 """
36
69
37 filesList = []
70 filesList = []
38 filename = None
71 filename = None
39
72
40 # 0 1234 567 89A BCDE
73 # 0 1234 567 89A BCDE
41 # D YYYY DDD SSS .ext
74 # D YYYY DDD SSS .ext
42
75
43 for filename in pathList:
76 for filename in pathList:
44 year = filename[1:5]
77 year = filename[1:5]
45 doy = filename[5:8]
78 doy = filename[5:8]
46 leng = len( ext )
79 leng = len( ext )
47
80
48 if ( filename[-leng:].upper() != ext.upper() ) : continue
81 if ( filename[-leng:].upper() != ext.upper() ) : continue
49 if not( isNumber( year ) ) : continue
82 if not( isNumber( year ) ) : continue
50 if not( isNumber( doy ) ) : continue
83 if not( isNumber( doy ) ) : continue
51
84
52 filesList.append(filename)
85 filesList.append(filename)
53
86
54 if len( filesList ) > 0:
87 if len( filesList ) > 0:
55 filesList = sorted( filesList, key=str.lower )
88 filesList = sorted( filesList, key=str.lower )
56 filename = filesList[-1]
89 filename = filesList[-1]
57
90
58 return filename
91 return filename
59
92
60
93
61 def checkForRealPath( path, year, doy, set, ext ):
94 def checkForRealPath(path,year,doy,set,ext):
62 """
95 """
63 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
96 Por ser Linux Case Sensitive la funcion checkForRealPath encuentra el nombre correcto de un path,
64 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
97 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
65 el path exacto de un determinado file.
98 el path exacto de un determinado file.
66
99
67 Example :
100 Example :
68 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
101 nombre correcto del file es ../RAWDATA/D2009307/P2009307367
69
102
70 Entonces la funcion prueba con las siguientes combinaciones
103 Entonces la funcion prueba con las siguientes combinaciones
71 ../RAWDATA/d2009307/p2009307367
104 ../.../d2009307/d2009307367
72 ../RAWDATA/d2009307/P2009307367
105 ../.../d2009307/D2009307367
73 ../RAWDATA/D2009307/p2009307367
106 ../.../D2009307/d2009307367
74 ../RAWDATA/D2009307/P2009307367
107 ../.../D2009307/D2009307367
75 siendo para este caso, la ultima combinacion de letras, identica al file buscado
108 siendo para este caso, la ultima combinacion de letras, identica al file buscado
76
109
77 Return:
110 Return:
78 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
111 Si encuentra la combinacion adecuada devuelve el path completo y el nombre del file
79 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
112 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
80 para el filename
113 para el filename
81 """
114 """
82 filepath = None
115 filepath = None
83 find_flag = False
116 find_flag = False
84 filename = None
117 filename = None
85
118
86 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
119 for dir in "dD": #barrido por las dos combinaciones posibles de "D"
87 for fil in "dD": #barrido por las dos combinaciones posibles de "D"
120 for fil in "dD": #barrido por las dos combinaciones posibles de "D"
88 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
121 doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
89 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
122 filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext (p=d o p=D)
90 filepath = os.path.join( path, doypath, filename ) #formo el path completo
123 filepath = os.path.join( path, doypath, filename ) #formo el path completo
91 if os.path.exists( filepath ): #verifico que exista
124 if os.path.exists( filepath ): #verifico que exista
92 find_flag = True
125 find_flag = True
93 break
126 break
94 if find_flag:
127 if find_flag:
95 break
128 break
96
129
97 if not(find_flag):
130 if not(find_flag):
98 return None, filename
131 return None, filename
99
132
100 return filepath, filename
133 return filepath, filename
101
134
102
135
103 def isNumber( str ):
136 def isNumber(str):
104 """
137 """
105 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
138 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
106
139
107 Excepciones:
140 Excepciones:
108 Si un determinado string no puede ser convertido a numero
141 Si un determinado string no puede ser convertido a numero
109 Input:
142 Input:
110 str, string al cual se le analiza para determinar si convertible a un numero o no
143 str, string al cual se le analiza para determinar si convertible a un numero o no
111
144
112 Return:
145 Return:
113 True : si el string es uno numerico
146 True : si el string es uno numerico
114 False : no es un string numerico
147 False : no es un string numerico
115 """
148 """
116 try:
149 try:
117 float( str )
150 float( str )
118 return True
151 return True
119 except:
152 except:
120 return False
153 return False
121
154
122
155
123 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
156 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
124 """
157 """
125 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
158 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
126 o no dentro del rango de fecha especificado.
159 o no dentro del rango de fecha especificado.
127
160
128 Inputs:
161 Inputs:
129 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
162 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
130
163
131 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
164 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
132 segundos contados desde 01/01/1970.
165 segundos contados desde 01/01/1970.
133 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
166 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
134 segundos contados desde 01/01/1970.
167 segundos contados desde 01/01/1970.
135
168
136 Return:
169 Return:
137 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
170 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
138 fecha especificado, de lo contrario retorna False.
171 fecha especificado, de lo contrario retorna False.
139
172
140 Excepciones:
173 Excepciones:
141 Si el archivo no existe o no puede ser abierto
174 Si el archivo no existe o no puede ser abierto
142 Si la cabecera no puede ser leida.
175 Si la cabecera no puede ser leida.
143
176
144 """
177 """
145 m_BasicHeader = BasicHeader()
178 m_BasicHeader = BasicHeader()
146
179
147 try:
180 try:
148 fp = open(filename,'rb')
181 fp = open(filename,'rb')
149 except:
182 except:
150 raise IOError, "The file %s can't be opened" %(filename)
183 raise IOError, "The file %s can't be opened" %(filename)
151
184
152 if not(m_BasicHeader.read(fp)):
185 if not(m_BasicHeader.read(fp)):
153 raise IOError, "The file %s has not a valid header" %(filename)
186 raise IOError, "The file %s has not a valid header" %(filename)
154
187
155 fp.close()
188 fp.close()
156
189
157 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
190 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
158 return 0
191 return 0
159
192
160 return 1
193 return 1
161
194
195
162 class VoltageReader(DataReader):
196 class VoltageReader(DataReader):
163 """
197 """
164 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
198 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
165 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
199 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
166 perfiles*alturas*canales) son almacenados en la variable "buffer".
200 perfiles*alturas*canales) son almacenados en la variable "buffer".
167
201
168 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
202 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
169 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
203 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
170 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
204 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
171 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
205 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
172
206
173 Example:
207 Example:
174
208
175 dpath = "/home/myuser/data"
209 dpath = "/home/myuser/data"
176
210
177 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
211 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
178
212
179 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
213 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
180
214
181 readerObj = VoltageReader()
215 readerObj = VoltageReader()
182
216
183 readerObj.setup(dpath, startTime, endTime)
217 readerObj.setup(dpath, startTime, endTime)
184
218
185 while(True):
219 while(True):
186
220
187 #to get one profile
221 #to get one profile
188 profile = readerObj.getData()
222 profile = readerObj.getData()
189
223
190 #print the profile
224 #print the profile
191 print profile
225 print profile
192
226
193 #If you want to see all datablock
227 #If you want to see all datablock
194 print readerObj.datablock
228 print readerObj.datablock
195
229
196 if readerObj.noMoreFiles:
230 if readerObj.noMoreFiles:
197 break
231 break
198
232
199 """
233 """
200
234
201 #speed of light
235 #speed of light
202 __c = 3E8
236 __c = 3E8
237
203
238
204 def __init__(self, m_Voltage = None):
239 def __init__(self,m_Voltage=None):
205 """
240 """
206 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
241 Inicializador de la clase VoltageReader para la lectura de datos de voltage.
207
242
208 Input:
243 Input:
209 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
244 m_Voltage : Objeto de la clase Voltage. Este objeto sera utilizado para
210 almacenar un perfil de datos cada vez que se haga un requerimiento
245 almacenar un perfil de datos cada vez que se haga un requerimiento
211 (getData). El perfil sera obtenido a partir del buffer de datos,
246 (getData). El perfil sera obtenido a partir del buffer de datos,
212 si el buffer esta vacio se hara un nuevo proceso de lectura de un
247 si el buffer esta vacio se hara un nuevo proceso de lectura de un
213 bloque de datos.
248 bloque de datos.
214 Si este parametro no es pasado se creara uno internamente.
249 Si este parametro no es pasado se creara uno internamente.
215
250
216 Variables afectadas:
251 Variables afectadas:
217 self.m_Voltage
252 self.m_Voltage
218 self.m_BasicHeader
253 self.m_BasicHeader
219 self.m_SystemHeader
254 self.m_SystemHeader
220 self.m_RadarControllerHeader
255 self.m_RadarControllerHeader
221 self.m_ProcessingHeader
256 self.m_ProcessingHeader
222
257
223
258
224 Return:
259 Return:
225 Void
260 Void
226
261
227 """
262 """
228 if m_Voltage == None:
263 if m_Voltage == None:
229 m_Voltage = Voltage()
264 m_Voltage = Voltage()
230
265
231 if not(isinstance(m_Voltage, Voltage)):
266 if not(isinstance(m_Voltage, Voltage)):
232 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
267 raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
233
268
234 self.m_Voltage = m_Voltage
269 self.m_Voltage = m_Voltage
235
270
236 self.m_BasicHeader = BasicHeader()
271 self.m_BasicHeader = BasicHeader()
237
272
238 self.m_SystemHeader = SystemHeader()
273 self.m_SystemHeader = SystemHeader()
239
274
240 self.m_RadarControllerHeader = RadarControllerHeader()
275 self.m_RadarControllerHeader = RadarControllerHeader()
241
276
242 self.m_ProcessingHeader = ProcessingHeader()
277 self.m_ProcessingHeader = ProcessingHeader()
243
278
244 self.__fp = None
279 self.__fp = None
245
280
246 self.__idFile = None
281 self.__idFile = None
247
282
248 self.__startDateTime = None
283 self.__startDateTime = None
249
284
250 self.__endDateTime = None
285 self.__endDateTime = None
251
286
252 self.__dataType = None
287 self.__dataType = None
253
288
254 self.__fileSizeByHeader = 0
289 self.__fileSizeByHeader = 0
255
290
256 self.__pathList = []
291 self.__pathList = []
257
292
258 self.filenameList = []
293 self.filenameList = []
259
294
260 self.__lastUTTime = 0
295 self.__lastUTTime = 0
261
296
262 self.__maxTimeStep = 30
297 self.__maxTimeStep = 30
263
298
264 self.__flagIsNewFile = 0
299 self.__flagIsNewFile = 0
265
300
266 self.__ippSeconds = 0
301 self.__ippSeconds = 0
267
302
268 self.flagResetProcessing = 0
303 self.flagResetProcessing = 0
269
304
270 self.flagIsNewBlock = 0
305 self.flagIsNewBlock = 0
271
306
272 self.noMoreFiles = 0
307 self.noMoreFiles = 0
273
308
274 self.nReadBlocks = 0
309 self.nReadBlocks = 0
275
310
276 self.online = 0
311 self.online = 0
277
312
278 self.filename = None
313 self.filename = None
279
314
280 self.fileSize = None
315 self.fileSize = None
281
316
282 self.firstHeaderSize = 0
317 self.firstHeaderSize = 0
283
318
284 self.basicHeaderSize = 24
319 self.basicHeaderSize = 24
285
320
286 self.idProfile = 0
321 self.idProfile = 0
287
322
288 self.datablock = None
323 self.datablock = None
289
324
290 self.__datablockIndex = 9999
325 self.__datablockIndex = 9999
291
326
292 self.__delay = 7 #seconds
327 self.__delay = 7 #seconds
293 self.__nTries = 3 #quantity tries
328 self.__nTries = 3 #quantity tries
294 self.__nFiles = 3 #number of files for searching
329 self.__nFiles = 3 #number of files for searching
295 self.__year = 0
330 self.__year = 0
296 self.__doy = 0
331 self.__doy = 0
297 self.__set = 0
332 self.__set = 0
298 self.__ext = None
333 self.__ext = None
299 self.__path = None
334 self.__path = None
300 self.__pts2read = 0
335 self.__pts2read = 0
301 self.__blocksize = 0
336 self.__blocksize = 0
337 self.__utc = 0
338 self.nBlocks = 0
339
302
340
303 def __rdSystemHeader(self,fp=None):
341 def __rdSystemHeader(self,fp=None):
304 if fp == None:
342 if fp == None:
305 fp = self.__fp
343 fp = self.__fp
306
344
307 self.m_SystemHeader.read(fp)
345 self.m_SystemHeader.read(fp)
346
308
347
309 def __rdRadarControllerHeader(self,fp=None):
348 def __rdRadarControllerHeader(self,fp=None):
310 if fp == None:
349 if fp == None:
311 fp = self.__fp
350 fp = self.__fp
312
351
313 self.m_RadarControllerHeader.read(fp)
352 self.m_RadarControllerHeader.read(fp)
353
314
354
315 def __rdProcessingHeader(self,fp=None):
355 def __rdProcessingHeader(self,fp=None):
316 if fp == None:
356 if fp == None:
317 fp = self.__fp
357 fp = self.__fp
318
358
319 self.m_ProcessingHeader.read(fp)
359 self.m_ProcessingHeader.read(fp)
320
360
321 def __rdBasicHeader(self, fp=None):
361
362 def __rdBasicHeader(self,fp=None):
322
363
323 if fp == None:
364 if fp == None:
324 fp = self.__fp
365 fp = self.__fp
325
366
326 self.m_BasicHeader.read(fp)
367 self.m_BasicHeader.read(fp)
368
327
369
328 def __readFirstHeader(self):
370 def __readFirstHeader(self):
329
371 """
372 Lectura del First Header, es decir el Basic Header y el Long Header
373
374 Affected:
375 self.m_BasicHeader
376 self.m_SystemHeader
377 self.m_RadarControllerHeader
378 self.m_ProcessingHeader
379 self.firstHeaderSize
380 self.__heights
381 self.__dataType
382 self.__fileSizeByHeader
383 self.__ippSeconds
384 self.__blocksize
385 self.__pts2read
386
387 Return: None
388 """
330 self.__rdBasicHeader()
389 self.__rdBasicHeader()
331 self.__rdSystemHeader()
390 self.__rdSystemHeader()
332 self.__rdRadarControllerHeader()
391 self.__rdRadarControllerHeader()
333 self.__rdProcessingHeader()
392 self.__rdProcessingHeader()
334 self.firstHeaderSize = self.m_BasicHeader.size
393 self.firstHeaderSize = self.m_BasicHeader.size
335
394
336 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
395 data_type=int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
337 if data_type == 0:
396 if data_type == 0:
338 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
397 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
339
398
340 elif data_type == 1:
399 elif data_type == 1:
341 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
400 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
342
401
343 elif data_type == 2:
402 elif data_type == 2:
344 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
403 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
345
404
346 elif data_type == 3:
405 elif data_type == 3:
347 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
406 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
348
407
349 elif data_type == 4:
408 elif data_type == 4:
350 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
409 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
351
410
352 elif data_type == 5:
411 elif data_type == 5:
353 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
412 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
354
413
355 else:
414 else:
356 raise ValueError, 'Data type was not defined'
415 raise ValueError, 'Data type was not defined'
357
416
358 xi = self.m_ProcessingHeader.firstHeight
417 xi = self.m_ProcessingHeader.firstHeight
359 step = self.m_ProcessingHeader.deltaHeight
418 step = self.m_ProcessingHeader.deltaHeight
360 xf = xi + self.m_ProcessingHeader.numHeights*step
419 xf = xi + self.m_ProcessingHeader.numHeights*step
361
420
362 self.__heights = numpy.arange(xi, xf, step)
421 self.__heights = numpy.arange(xi, xf, step)
363 self.__dataType = tmp
422 self.__dataType = tmp
364 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
423 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
365 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
424 self.__ippSeconds = 2*1000*self.m_RadarControllerHeader.ipp/self.__c
366
425
367 self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
426 self.__pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
368 self.__blocksize = self.__pts2read
427 self.__blocksize = self.__pts2read
369
428
370
429
371 def __setNextFileOnline( self ):
430 def __setNextFileOnline(self):
372 """
431 """
373 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
432 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
374 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
433 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
375 siguientes.
434 siguientes.
376
435
377 Affected:
436 Affected:
378 self.__flagIsNewFile
437 self.__flagIsNewFile
379 self.filename
438 self.filename
380 self.fileSize
439 self.fileSize
381 self.__fp
440 self.__fp
382 self.__set
441 self.__set
383 self.noMoreFiles
442 self.noMoreFiles
384
443
385 Return:
444 Return:
386 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
445 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
387 1 : si el file fue abierto con exito y esta listo a ser leido
446 1 : si el file fue abierto con exito y esta listo a ser leido
388
447
389 Excepciones:
448 Excepciones:
390 Si un determinado file no puede ser abierto
449 Si un determinado file no puede ser abierto
391 """
450 """
392 countFiles = 0
451 countFiles = 0
393 countTries = 0
452 countTries = 0
394
453
395 fileStatus = 0
396 notFirstTime_flag = False
454 notFirstTime_flag = False
397 bChangeDir = False
455 fileOk_flag = False
398
456 changeDir_flag = False
399 fileSize = 0
400 fp = None
401
457
402 self.__flagIsNewFile = 0
458 self.__flagIsNewFile = 0
403
459
404 while( True ): #este loop permite llevar la cuenta de intentos, de files y carpetas,
460 while( True ): #este loop permite llevar la cuenta de intentos, de files y carpetas,
405 #si no encuentra alguno sale del bucle
461 #si no encuentra alguno sale del bucle
406 countFiles += 1
462 countFiles += 1
407
463
408 if countFiles > (self.__nFiles + 1):
464 if countFiles > (self.__nFiles + 1):
409 break
465 break
410
466
411 self.__set += 1
467 self.__set += 1
412
468
413 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
469 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
414 self.__set = 0
470 self.__set = 0
415 self.__doy += 1
471 self.__doy += 1
416 bChangeDir = True
472 changeDir_flag = True
417
473
418 file = None
474 file = None
419 filename = None
475 filename = None
476 fileOk_flag = False
477
478 #busca el 1er file disponible
479 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
480
481 if file == None:
482 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
483 print "\tsearching next \"%s\" file ..." % ( filename )
484 continue
485 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
486 for nTries in range( self.__nTries ):
487 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
488 time.sleep( self.__delay )
489
490 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
491 if file != None:
492 fileOk_flag = True
493 break
494
495 if not( fileOk_flag ): #no encontro ningun file valido a leer despues de haber esperado alguno
496 notFirstTime_flag = True
497 continue
498
499 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
500 currentSize = os.path.getsize( file )
501 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
420
502
421 countTries = 0
503 #si el tamanho es suficiente entonces deja de buscar
504 if currentSize > neededSize:# and (neededSize != 0):
505 fileOk_flag = True
506 break
422
507
423 #espero hasta encontrar el 1er file disponible
508 fileOk_flag = False
424 while( True ):
509 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
425
510 #por una cierta cantidad de veces hasta que el contenido del file sea valido
426 countTries += 1
511 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
427 if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
512 print "\tsearching next \"%s\" file ..." % filename
428 break
513 changeDir_flag = False
429
514 continue
430 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
515
431 if file != None:
516 for nTries in range( self.__nTries ):
432 break
517 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
433
434 if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
435 countTries = self.__nTries
436 print "\tsearching next \"%s\" file ..." % filename
437 break
438
439 print "\twaiting new \"%s\" file ..." % filename
440 time.sleep( self.__delay )
518 time.sleep( self.__delay )
441
519
442 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
520 currentSize = os.path.getsize( file )
443 notFirstTime_flag = True
444 continue #vuelvo al inico del while principal
445
446 countTries = 0
447
448 #una vez que se obtuvo el 1er file valido se procede a checkear su contenido, y se espera una cierta cantidad
449 #de tiempo por una cierta cantidad de veces hasta que el contenido del file sea un contenido valido
450 while( True ):
451 countTries += 1
452 if countTries > self.__nTries:
453 break
454
455 try:
456 fp = open(file)
457 except:
458 print "The file \"%s\" can't be opened" % file
459 break
460
461 fileSize = os.path.getsize( file )
462 currentSize = fileSize - fp.tell()
463 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
521 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
464
522
465 if currentSize > neededSize:
523 if currentSize > neededSize:
466 fileStatus = 1
524 fileOk_flag = True
467 break
468
469 fp.close()
470
471 if bChangeDir: #si al buscar un file cambie de directorio ya no espero y salgo del bucle while
472 print "\tsearching next \"%s\" file ..." % filename
473 break
525 break
474
526
475 print "\twaiting for block of \"%s\" file ..." % filename
527 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
476 time.sleep( self.__delay )
477
478 if fileStatus == 1:
479 break
528 break
480
529
481 print "Skipping the file \"%s\" due to this files is empty" % filename
530 print "Skipping the file \"%s\" due to this files is empty" % filename
482 countFiles = 0
531 countFiles = 0
483
532
484
533 if fileOk_flag:
485 if fileStatus == 1:
534 self.fileSize = os.path.getsize( file ) #fileSize
486 self.fileSize = fileSize
487 self.filename = file
535 self.filename = file
488 self.__flagIsNewFile = 1
536 self.__flagIsNewFile = 1
489 self.__fp = fp
537 if self.__fp != None: self.__fp.close()
538 self.__fp = open(file)
490 self.noMoreFiles = 0
539 self.noMoreFiles = 0
491 print 'Setting the file: %s' % file
540 print 'Setting the file: %s' % file
492 else:
541 else:
493 self.fileSize = 0
542 self.fileSize = 0
494 self.filename = None
543 self.filename = None
495 self.__fp = None
544 self.__fp = None
496 self.noMoreFiles = 1
545 self.noMoreFiles = 1
497 print 'No more Files'
546 print 'No more Files'
498
547
499 return fileStatus
548 return fileOk_flag
500
549
501
550
502 def __setNextFileOffline(self):
551 def __setNextFileOffline(self):
503
552
504 idFile = self.__idFile
553 idFile = self.__idFile
505 while(True):
554 while(True):
506
555
507 idFile += 1
556 idFile += 1
508
557
509 if not(idFile < len(self.filenameList)):
558 if not(idFile < len(self.filenameList)):
510 self.noMoreFiles = 1
559 self.noMoreFiles = 1
560 print 'No more Files'
511 return 0
561 return 0
512
562
513 filename = self.filenameList[idFile]
563 filename = self.filenameList[idFile]
514 fileSize = os.path.getsize(filename)
564 fileSize = os.path.getsize(filename)
515
565
516 try:
566 try:
517 fp = open(filename,'rb')
567 fp = open(filename,'rb')
518 except:
568 except:
519 raise IOError, "The file %s can't be opened" %filename
569 raise IOError, "The file %s can't be opened" %filename
520
570
521 currentSize = fileSize - fp.tell()
571 currentSize = fileSize - fp.tell()
522 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
572 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
523
573
524 if (currentSize < neededSize):
574 if (currentSize < neededSize):
525 print "Skipping the file %s due to it hasn't enough data" %filename
575 print "Skipping the file %s due to it hasn't enough data" %filename
526 continue
576 continue
527
577
528 break
578 break
529
579
530 self.__flagIsNewFile = 1
580 self.__flagIsNewFile = 1
531 self.__idFile = idFile
581 self.__idFile = idFile
532 self.filename = filename
582 self.filename = filename
533 self.fileSize = fileSize
583 self.fileSize = fileSize
534 self.__fp = fp
584 self.__fp = fp
535
585
536 print 'Setting the file: %s'%self.filename
586 print 'Setting the file: %s'%self.filename
537
587
538 return 1
588 return 1
539
589
540 def __setNextFile( self ):
590
591 def __setNextFile(self):
541 """
592 """
542 Determina el siguiente file a leer y si hay uno disponible lee el First Header
593 Determina el siguiente file a leer y si hay uno disponible lee el First Header
543
594
544 Affected:
595 Affected:
545 self.m_BasicHeader
596 self.m_BasicHeader
546 self.m_SystemHeader
597 self.m_SystemHeader
547 self.m_RadarControllerHeader
598 self.m_RadarControllerHeader
548 self.m_ProcessingHeader
599 self.m_ProcessingHeader
549 self.firstHeaderSize
600 self.firstHeaderSize
550
601
551 Return:
602 Return:
552 0 : Si no hay files disponibles
603 0 : Si no hay files disponibles
553 1 : Si hay mas files disponibles
604 1 : Si hay mas files disponibles
554 """
605 """
555 if self.__fp != None:
606 if self.__fp != None:
556 self.__fp.close()
607 self.__fp.close()
557
608
558 if self.online:
609 if self.online:
559 newFile = self.__setNextFileOnline()
610 newFile = self.__setNextFileOnline()
560 else:
611 else:
561 newFile = self.__setNextFileOffline()
612 newFile = self.__setNextFileOffline()
562
613
614 if self.noMoreFiles:
615 sys.exit(0)
616
563 if not(newFile):
617 if not(newFile):
564 return 0
618 return 0
565
619
566 self.__readFirstHeader()
620 self.__readFirstHeader()
567
621 self.nBlocks = 0
568 return 1
622 return 1
569
623
570
624
571 def __setNewBlock( self ):
625 def __setNewBlock(self):
572 """
626 """
573 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
627 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
574
628
575 Affected:
629 Affected:
576 self.m_BasicHeader
630 self.m_BasicHeader
577 self.flagResetProcessing
631 self.flagResetProcessing
578 self.ns
632 self.ns
579
633
580 Return:
634 Return:
581 0 : Si el file no tiene un Basic Header que pueda ser leido
635 0 : Si el file no tiene un Basic Header que pueda ser leido
582 1 : Si se pudo leer el Basic Header
636 1 : Si se pudo leer el Basic Header
583 """
637 """
584 if self.__fp == None:
638 if self.__fp == None:
585 return 0
639 return 0
586
640
587 if self.__flagIsNewFile:
641 if self.__flagIsNewFile:
588 return 1
642 return 1
589
643
590 currentSize = self.fileSize - self.__fp.tell()
644 currentSize = self.fileSize - self.__fp.tell()
591 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
645 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
592
646
593 #If there is enough data setting new data block
647 #If there is enough data setting new data block
594 if ( currentSize >= neededSize ):
648 if ( currentSize >= neededSize ):
595 self.__rdBasicHeader()
649 self.__rdBasicHeader()
596 return 1
650 return 1
597 elif self.online:
651
598 nTries = 0
652 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
599 while( nTries < self.__nTries ):
653 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
600 nTries += 1
654 for nTries in range( self.__nTries ):
601 print "Waiting for the next block, try %03d ..." % nTries
655
656 fpointer = self.__fp.tell()
657 self.__fp.close()
658
659 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
602 time.sleep( self.__delay )
660 time.sleep( self.__delay )
603
661
604 fileSize = os.path.getsize(self.filename)
662 self.__fp = open( self.filename, 'rb' )
605 currentSize = fileSize - self.__fp.tell()
663 self.__fp.seek( fpointer )
664
665 self.fileSize = os.path.getsize( self.filename )
666 currentSize = self.fileSize - self.__fp.tell()
606 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
667 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
607
668
608 if ( currentSize >= neededSize ):
669 if ( currentSize >= neededSize ):
609 self.__rdBasicHeader()
670 self.__rdBasicHeader()
610 return 1
671 return 1
611
672
612 #Setting new file
673 #Setting new file
613 if not( self.__setNextFile() ):
674 if not( self.__setNextFile() ):
614 return 0
675 return 0
615
676
616 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
677 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
617
678
618 self.flagResetProcessing = 0
679 self.flagResetProcessing = 0
619
680
620 if deltaTime > self.__maxTimeStep:
681 if deltaTime > self.__maxTimeStep:
621 self.flagResetProcessing = 1
682 self.flagResetProcessing = 1
622 self.nReadBlocks = 0
683 #self.nReadBlocks = 0
623
684
624 return 1
685 return 1
686
625
687
626 def __readBlock(self):
688 def __readBlock(self):
627 """
689 """
628 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
690 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
629 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
691 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
630 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
692 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
631 es seteado a 0
693 es seteado a 0
632
694
633
634 Inputs:
695 Inputs:
635 None
696 None
636
697
637 Return:
698 Return:
638 None
699 None
639
700
640 Variables afectadas:
701 Affected:
641
642 self.__datablockIndex
702 self.__datablockIndex
643
644 self.datablock
703 self.datablock
645
646 self.__flagIsNewFile
704 self.__flagIsNewFile
647
648 self.idProfile
705 self.idProfile
649
650 self.flagIsNewBlock
706 self.flagIsNewBlock
651
652 self.nReadBlocks
707 self.nReadBlocks
653
708
709 Exceptions:
710 Si un bloque leido no es un bloque valido
654 """
711 """
655
712 blockOk_flag = False
656 #pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
657
658 fpointer = self.__fp.tell()
713 fpointer = self.__fp.tell()
659
714
660 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
715 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
661
716
662 if self.online:
717 if self.online:
663 if junk.size != self.__blocksize:
718 if junk.size != self.__blocksize:
664 nTries = 0
719 for nTries in range( self.__nTries ):
665 while( nTries < self.__nTries ):
720 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
666 nTries += 1
667 print "Waiting for the next block, try %03d ..." % nTries
668 time.sleep( self.__delay )
721 time.sleep( self.__delay )
669 self.__fp.seek( fpointer )
722 self.__fp.seek( fpointer )
670 fpointer = self.__fp.tell()
723 fpointer = self.__fp.tell()
671 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
724 junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
672 if junk.size == self.__blocksize:
725 if junk.size == self.__blocksize:
673 nTries = 0
726 blockOk_flag = True
674 break
727 break
675 if nTries > 0:
728
676 return
729 if not( blockOk_flag ):
730 return 0
677
731
678 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
732 try:
733 junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
734 except:
735 print "Data file %s is invalid" % self.filename
736 return 0
679
737
680 data = junk['real'] + junk['imag']*1j
738 #data = junk['real'] + junk['imag']*1j
739 self.datablock = junk['real'] + junk['imag']*1j
681
740
682 self.__datablockIndex = 0
741 self.__datablockIndex = 0
683
684 self.datablock = data
685
686 self.__flagIsNewFile = 0
742 self.__flagIsNewFile = 0
687
688 self.idProfile = 0
743 self.idProfile = 0
689
690 self.flagIsNewBlock = 1
744 self.flagIsNewBlock = 1
691
745
692 self.nReadBlocks += 1
746 self.nReadBlocks += 1
747 self.nBlocks += 1
748
749 return 1
750
693
751
694 def __hasNotDataInBuffer(self):
752 def __hasNotDataInBuffer(self):
695 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
753 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
696 return 1
754 return 1
697
698 return 0
755 return 0
699
756
700
757
701 def __searchFilesOnLine( self, path, startDateTime=None, ext = ".r" ):
758 def __searchFilesOnLine(self, path, startDateTime=None, ext = ".r"):
702 """
759 """
703 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
760 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
704 devuelve el archivo encontrado ademas de otros datos.
761 devuelve el archivo encontrado ademas de otros datos.
705
762
706 Input:
763 Input:
707 path : carpeta donde estan contenidos los files que contiene data
764 path : carpeta donde estan contenidos los files que contiene data
708 startDateTime : punto especifico en el tiempo del cual se requiere la data
765 startDateTime : punto especifico en el tiempo del cual se requiere la data
709 ext : extension de los files
766 ext : extension de los files
710
767
711 Return:
768 Return:
712 year : el anho
769 year : el anho
713 doy : el numero de dia del anho
770 doy : el numero de dia del anho
714 set : el set del archivo
771 set : el set del archivo
715 filename : el ultimo file de una determinada carpeta
772 filename : el ultimo file de una determinada carpeta
716 directory : eL directorio donde esta el file encontrado
773 directory : eL directorio donde esta el file encontrado
717 """
774 """
718
719 print "Searching files ..."
775 print "Searching files ..."
720
776
721 dirList = []
777 dirList = []
722 directory = None
778 directory = None
723
779
724 if startDateTime == None:
780 if startDateTime == None:
725 for thisPath in os.listdir(path):
781 for thisPath in os.listdir(path):
726 if os.path.isdir( os.path.join(path,thisPath) ):
782 if os.path.isdir( os.path.join(path,thisPath) ):
727 dirList.append( thisPath )
783 dirList.append( thisPath )
728
784
729 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
785 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
730 if len(dirList) > 0 :
786 if len(dirList) > 0 :
731 directory = dirList[-1]
787 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
732 else:
788 else:
733 year = startDateTime.timetuple().tm_year
789 year = startDateTime.timetuple().tm_year
734 doy = startDateTime.timetuple().tm_yday
790 doy = startDateTime.timetuple().tm_yday
735
791
736 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
792 doyPath = "D%04d%03d" % (year,doy) #caso del nombre en mayusculas
737 if os.path.isdir( os.path.join(path,doyPath) ):
793 if os.path.isdir( os.path.join(path,doyPath) ):
738 directory = doyPath
794 directory = doyPath
739
795
740 doyPath = doyPath.lower() #caso del nombre en minusculas
796 doyPath = doyPath.lower() #caso del nombre en minusculas
741 if os.path.isdir( os.path.join(path,doyPath) ):
797 if os.path.isdir( os.path.join(path,doyPath) ):
742 directory = doyPath
798 directory = doyPath
743
799
744 if directory == None:
800 if directory == None:
745 return 0, 0, 0, None, None
801 return 0, 0, 0, None, None
746
802
747 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
803 filename = getlastFileFromPath( os.listdir( os.path.join(path,directory) ), ext )
748
804
749 if filename == None:
805 if filename == None:
750 return 0, 0, 0, None, None
806 return 0, 0, 0, None, None
751
807
752 year = int( directory[-7:-3] )
808 year = int( directory[-7:-3] )
753 doy = int( directory[-3:] )
809 doy = int( directory[-3:] )
754 ln = len( ext )
810 ln = len( ext )
755 set = int( filename[-ln-3:-ln] )
811 set = int( filename[-ln-3:-ln] )
756
812
757 return year, doy, set, filename, directory
813 return year, doy, set, filename, directory
758
814
759
815
760 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
816 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
761 """
817 """
762 Realiza una busqueda de los archivos que coincidan con los parametros
818 Realiza una busqueda de los archivos que coincidan con los parametros
763 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
819 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
764 correcta la estructura de directorios debe ser la siguiente:
820 correcta la estructura de directorios debe ser la siguiente:
765
821
766 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
822 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
767
823
768 [yyyy]: anio
824 [yyyy]: anio
769 [ddd] : dia del anio
825 [ddd] : dia del anio
770 [sss] : set del archivo
826 [sss] : set del archivo
771
827
772 Inputs:
828 Inputs:
773 path : Directorio de datos donde se realizara la busqueda. Todos los
829 path : Directorio de datos donde se realizara la busqueda. Todos los
774 ficheros que concidan con el criterio de busqueda seran
830 ficheros que concidan con el criterio de busqueda seran
775 almacenados en una lista y luego retornados.
831 almacenados en una lista y luego retornados.
776 startDateTime : Fecha inicial. Rechaza todos los archivos donde
832 startDateTime : Fecha inicial. Rechaza todos los archivos donde
777 file end time < startDateTime (obejto datetime.datetime)
833 file end time < startDateTime (obejto datetime.datetime)
778
834
779 endDateTime : Fecha final. Rechaza todos los archivos donde
835 endDateTime : Fecha final. Rechaza todos los archivos donde
780 file start time > endDateTime (obejto datetime.datetime)
836 file start time > endDateTime (obejto datetime.datetime)
781
837
782 set : Set del primer archivo a leer. Por defecto None
838 set : Set del primer archivo a leer. Por defecto None
783
839
784 expLabel : Nombre del subdirectorio de datos. Por defecto ""
840 expLabel : Nombre del subdirectorio de datos. Por defecto ""
785
841
786 ext : Extension de los archivos a leer. Por defecto .r
842 ext : Extension de los archivos a leer. Por defecto .r
787
843
788 Return:
844 Return:
789
845
790 (pathList, filenameList)
846 (pathList, filenameList)
791
847
792 pathList : Lista de directorios donde se encontraron archivos dentro
848 pathList : Lista de directorios donde se encontraron archivos dentro
793 de los parametros especificados
849 de los parametros especificados
794 filenameList : Lista de archivos (ruta completa) que coincidieron con los
850 filenameList : Lista de archivos (ruta completa) que coincidieron con los
795 parametros especificados.
851 parametros especificados.
796
852
797 Variables afectadas:
853 Variables afectadas:
798
854
799 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
855 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
800 como fuente para leer los bloque de datos, si se termina
856 como fuente para leer los bloque de datos, si se termina
801 de leer todos los bloques de datos de un determinado
857 de leer todos los bloques de datos de un determinado
802 archivo se pasa al siguiente archivo de la lista.
858 archivo se pasa al siguiente archivo de la lista.
803
859
804 Excepciones:
860 Excepciones:
805
861
806 """
862 """
807
808 print "Searching files ..."
863 print "Searching files ..."
809
864
810 dirList = []
865 dirList = []
811 for thisPath in os.listdir(path):
866 for thisPath in os.listdir(path):
812 if os.path.isdir(os.path.join(path,thisPath)):
867 if os.path.isdir(os.path.join(path,thisPath)):
813 dirList.append(thisPath)
868 dirList.append(thisPath)
814
869
815 pathList = []
870 pathList = []
816
871
817 thisDateTime = startDateTime
872 thisDateTime = startDateTime
818
873
819 while(thisDateTime <= endDateTime):
874 while(thisDateTime <= endDateTime):
820 year = thisDateTime.timetuple().tm_year
875 year = thisDateTime.timetuple().tm_year
821 doy = thisDateTime.timetuple().tm_yday
876 doy = thisDateTime.timetuple().tm_yday
822
877
823 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
878 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
824 if len(match) == 0:
879 if len(match) == 0:
825 thisDateTime += datetime.timedelta(1)
880 thisDateTime += datetime.timedelta(1)
826 continue
881 continue
827
882
828 pathList.append(os.path.join(path,match[0],expLabel))
883 pathList.append(os.path.join(path,match[0],expLabel))
829 thisDateTime += datetime.timedelta(1)
884 thisDateTime += datetime.timedelta(1)
830
885
831 startUtSeconds = time.mktime(startDateTime.timetuple())
886 startUtSeconds = time.mktime(startDateTime.timetuple())
832 endUtSeconds = time.mktime(endDateTime.timetuple())
887 endUtSeconds = time.mktime(endDateTime.timetuple())
833
888
834 filenameList = []
889 filenameList = []
835 for thisPath in pathList:
890 for thisPath in pathList:
836 fileList = glob.glob1(thisPath, "*%s" %ext)
891 fileList = glob.glob1(thisPath, "*%s" %ext)
837 fileList.sort()
892 fileList.sort()
838 for file in fileList:
893 for file in fileList:
839 filename = os.path.join(thisPath,file)
894 filename = os.path.join(thisPath,file)
840 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
895 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
841 filenameList.append(filename)
896 filenameList.append(filename)
842
897
843 self.filenameList = filenameList
898 self.filenameList = filenameList
844
899
845 return pathList, filenameList
900 return pathList, filenameList
846
901
847
902
848 def __initFilesOnline( self, path, dirfilename, filename ):
903 def __initFilesOnline( self, path, dirfilename, filename ):
849 """
904 """
850 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
905 Verifica que el primer file tenga una data valida, para ello leo el 1er bloque
851 del file, si no es un file valido espera una cierta cantidad de tiempo a que
906 del file, si no es un file valido espera una cierta cantidad de tiempo a que
852 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
907 lo sea, si transcurrido el tiempo no logra validar el file entonces el metodo
853 devuelve 0 caso contrario devuelve 1
908 devuelve 0 caso contrario devuelve 1
854
909
855 Affected:
910 Affected:
856 m_BasicHeader
911 m_BasicHeader
857
912
858 Return:
913 Return:
859 0 : file no valido para ser leido
914 0 : file no valido para ser leido
860 1 : file valido para ser leido
915 1 : file valido para ser leido
861 """
916 """
862 m_BasicHeader = BasicHeader()
917 m_BasicHeader = BasicHeader()
863
918
864 file = os.path.join( path, dirfilename, filename )
919 file = os.path.join( path, dirfilename, filename )
865
920
866 nTries = 0
921 for nTries in range( self.__nTries+1 ):
867 while(True):
868
869 nTries += 1
870 if nTries > self.__nTries:
871 break
872
873 try:
922 try:
874 fp = open( file,'rb' ) #lectura binaria
923 fp = open( file,'rb' ) #lectura binaria
875 except:
924 except:
876 raise IOError, "The file %s can't be opened" %(file)
925 raise IOError, "The file %s can't be opened" % (file)
877
926
878 try:
927 try:
879 m_BasicHeader.read(fp)
928 m_BasicHeader.read(fp)
880 except:
929 except:
881 print "The file %s is empty" % filename
930 print "The file %s is empty" % filename
882
931
883 fp.close()
932 fp.close()
933 fp = None
884
934
885 if m_BasicHeader.size > 24:
935 if m_BasicHeader.size > 24:
886 break
936 break
887
937
888 print 'waiting for new block: try %02d' % ( nTries )
938 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
889 time.sleep( self.__delay)
939 break
890
940
941 print '\twaiting for new block: try %02d' % ( nTries )
942 time.sleep( self.__delay )
943
891 if m_BasicHeader.size <= 24:
944 if m_BasicHeader.size <= 24:
892 return 0
945 return 0
893
946
894 return 1
947 return 1
895
948
896
949
897 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
950 def setup(self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".r", online = 0):
898 """
951 """
899 setup configura los parametros de lectura de la clase VoltageReader.
952 setup configura los parametros de lectura de la clase VoltageReader.
900
953
901 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
954 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
902 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
955 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
903 self.filenameList.
956 self.filenameList.
904
957
905 Input:
958 Input:
906 path : Directorios donde se ubican los datos a leer. Dentro de este
959 path : Directorios donde se ubican los datos a leer. Dentro de este
907 directorio deberia de estar subdirectorios de la forma:
960 directorio deberia de estar subdirectorios de la forma:
908
961
909 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
962 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
910
963
911 startDateTime : Fecha inicial. Rechaza todos los archivos donde
964 startDateTime : Fecha inicial. Rechaza todos los archivos donde
912 file end time < startDatetime (obejto datetime.datetime)
965 file end time < startDatetime (obejto datetime.datetime)
913
966
914 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
967 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
915 file end time < startDatetime (obejto datetime.datetime)
968 file end time < startDatetime (obejto datetime.datetime)
916
969
917 set : Set del primer archivo a leer. Por defecto None
970 set : Set del primer archivo a leer. Por defecto None
918
971
919 expLabel : Nombre del subdirectorio de datos. Por defecto ""
972 expLabel : Nombre del subdirectorio de datos. Por defecto ""
920
973
921 ext : Extension de los archivos a leer. Por defecto .r
974 ext : Extension de los archivos a leer. Por defecto .r
922
975
923 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
976 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
924
977
925 Return:
978 Return:
926 0 : Si no encuentra files que cumplan con las condiciones dadas
979 0 : Si no encuentra files que cumplan con las condiciones dadas
927 1 : Si encuentra files que cumplan con las condiciones dadas
980 1 : Si encuentra files que cumplan con las condiciones dadas
928
981
929 Affected:
982 Affected:
930 self.startUTCSeconds
983 self.startUTCSeconds
931 self.endUTCSeconds
984 self.endUTCSeconds
932 self.startYear
985 self.startYear
933 self.endYear
986 self.endYear
934 self.startDoy
987 self.startDoy
935 self.endDoy
988 self.endDoy
936 self.__pathList
989 self.__pathList
937 self.filenameList
990 self.filenameList
938 self.online
991 self.online
939 """
992 """
940 if online:
993 if online:
941 nTries = 0
994 fileOK_flag = False
942 while( nTries < self.__nTries ):
995 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
943 nTries += 1
996 file = os.path.join( path, subfolder )
944 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
997
998 for nTries in range( self.__nTries+1 ): #espera por el 1er file
945 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
999 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
946 if filename == None:
1000
947 file = os.path.join( path, subfolder )
1001 if filename != None:
948 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries )
1002 if isFileOK( os.path.join( path,dirfilename,filename ) ):
949 time.sleep( self.__delay )
1003 fileOK_flag = True
950 else:
1004 break
1005
1006 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
951 break
1007 break
1008
1009 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1010 time.sleep( self.__delay )
952
1011
953 if filename == None:
1012 if not( fileOK_flag ): #filename == None:
954 print "No files On Line"
1013 print "No files on line or invalid first file"
955 return 0
1014 return 0
956
1015
957 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1016 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
958 print "The file %s hasn't enough data"
1017 print "The file %s hasn't enough data" % filename
959 return 0
1018 return 0
960
1019
961 self.__year = year
1020 self.__year = year
962 self.__doy = doy
1021 self.__doy = doy
963 self.__set = set - 1
1022 self.__set = set - 1
964 self.__path = path
1023 self.__path = path
965
1024
966 else:
1025 else:
967 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
1026 pathList, filenameList = self.__searchFilesOffLine( path, startDateTime, endDateTime, set, expLabel, ext )
968 self.__idFile = -1
1027 self.__idFile = -1
969 self.__pathList = pathList
1028 self.__pathList = pathList
970 self.filenameList = filenameList
1029 self.filenameList = filenameList
971
1030
972 self.online = online
1031 self.online = online
973 self.__ext = ext
1032 self.__ext = ext
974
1033
975 if not( self.__setNextFile() ):
1034 if not( self.__setNextFile() ):
976 if (startDateTime != None) and (endDateTime != None):
1035 if (startDateTime != None) and (endDateTime != None):
977 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
1036 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
978 elif startDateTime != None:
1037 elif startDateTime != None:
979 print "No files in : %s" % startDateTime.ctime()
1038 print "No files in : %s" % startDateTime.ctime()
980 else:
1039 else:
981 print "No files"
1040 print "No files"
982 return 0
1041 return 0
983
1042
984 if startDateTime != None:
1043 if startDateTime != None:
985 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
1044 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
986 self.startYear = startDateTime.timetuple().tm_year
1045 self.startYear = startDateTime.timetuple().tm_year
987 self.startDoy = startDateTime.timetuple().tm_yday
1046 self.startDoy = startDateTime.timetuple().tm_yday
988
1047
989 if endDateTime != None:
1048 if endDateTime != None:
990 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
1049 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
991 self.endYear = endDateTime.timetuple().tm_year
1050 self.endYear = endDateTime.timetuple().tm_year
992 self.endDoy = endDateTime.timetuple().tm_yday
1051 self.endDoy = endDateTime.timetuple().tm_yday
993 #call fillHeaderValues() - to Data Object
1052 #call fillHeaderValues() - to Data Object
994
1053
995 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1054 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
996 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1055 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
997 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1056 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
998 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1057 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
999 self.m_Voltage.dataType = self.__dataType
1058 self.m_Voltage.dataType = self.__dataType
1000
1059
1001 return 1
1060 return 1
1002
1061
1003
1062
1004 def readNextBlock( self ):
1063 def readNextBlock(self):
1005 """
1064 """
1006 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1065 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
1007 mas bloques disponibles en el archivo actual salta al siguiente.
1066 mas bloques disponibles en el archivo actual salta al siguiente.
1008
1067
1009 Affected:
1068 Affected:
1010 self.__lastUTTime
1069 self.__lastUTTime
1011
1070
1012 Return: None
1071 Return: None
1013 """
1072 """
1014 if not(self.__setNewBlock()):
1073 if not(self.__setNewBlock()):
1015 return 0
1074 return 0
1016
1075
1017 self.__readBlock()
1076 if not( self.__readBlock() ):
1077 return 0
1018
1078
1019 self.__lastUTTime = self.m_BasicHeader.utc
1079 self.__lastUTTime = self.m_BasicHeader.utc
1020
1080
1021 return 1
1081 return 1
1022
1082
1023
1083
1024 def getData( self ):
1084 def getData(self):
1025 """
1085 """
1026 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1086 getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
1027 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1087 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1028 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1088 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
1029
1089
1030 Ademas incrementa el contador del buffer en 1.
1090 Ademas incrementa el contador del buffer en 1.
1031
1091
1032 Return:
1092 Return:
1033 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1093 data : retorna un perfil de voltages (alturas * canales) copiados desde el
1034 buffer. Si no hay mas archivos a leer retorna None.
1094 buffer. Si no hay mas archivos a leer retorna None.
1035
1095
1036 Variables afectadas:
1096 Variables afectadas:
1037 self.m_Voltage
1097 self.m_Voltage
1038 self.__datablockIndex
1098 self.__datablockIndex
1039 self.idProfile
1099 self.idProfile
1040
1100
1041 Affected:
1101 Affected:
1042 self.m_Voltage
1102 self.m_Voltage
1043 self.__datablockIndex
1103 self.__datablockIndex
1044 self.flagResetProcessing
1104 self.flagResetProcessing
1045 self.flagIsNewBlock
1105 self.flagIsNewBlock
1046 self.idProfile
1106 self.idProfile
1047 """
1107 """
1108 if self.noMoreFiles: return 0
1109
1048 self.flagResetProcessing = 0
1110 self.flagResetProcessing = 0
1049 self.flagIsNewBlock = 0
1111 self.flagIsNewBlock = 0
1050
1112
1051 if self.__hasNotDataInBuffer():
1113 if self.__hasNotDataInBuffer():
1052
1114
1053 self.readNextBlock()
1115 if not( self.readNextBlock() ):
1116 self.__setNextFile()
1117 return 0
1054
1118
1055 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1119 self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
1056 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1120 self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1057 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1121 self.m_Voltage.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
1058 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1122 self.m_Voltage.m_SystemHeader = self.m_SystemHeader.copy()
1059 self.m_Voltage.heights = self.__heights
1123 self.m_Voltage.heights = self.__heights
1060 self.m_Voltage.dataType = self.__dataType
1124 self.m_Voltage.dataType = self.__dataType
1061
1125
1062 if self.noMoreFiles == 1:
1126 if self.noMoreFiles == 1:
1063 print 'Process finished'
1127 print 'Process finished'
1064 return None
1128 return 0
1065
1129
1066 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1130 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1067
1131
1132 if self.datablock == None:
1133 self.m_Voltage.flagNoData = True
1134 return 0
1135
1068 time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
1136 time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
1069 self.m_Voltage.m_BasicHeader.utc = time
1137 self.__utc = time
1138 #self.m_Voltage.m_BasicHeader.utc = time
1070
1139
1071 self.m_Voltage.flagNoData = False
1140 self.m_Voltage.flagNoData = False
1072 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
1141 self.m_Voltage.flagResetProcessing = self.flagResetProcessing
1073
1142
1074 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
1143 self.m_Voltage.data = self.datablock[self.__datablockIndex,:,:]
1075 self.m_Voltage.idProfile = self.idProfile
1144 self.m_Voltage.idProfile = self.idProfile
1076
1145
1077 self.__datablockIndex += 1
1146 self.__datablockIndex += 1
1078 self.idProfile += 1
1147 self.idProfile += 1
1079
1148
1080 #call setData - to Data Object
1149 #call setData - to Data Object
1081
1150
1082 return self.m_Voltage.data
1151 return 1 #self.m_Voltage.data
1083
1152
1084
1153
1085 class VoltageWriter( DataWriter ):
1154 class VoltageWriter(DataWriter):
1086 """
1155 """
1087 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1156 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
1088 de los datos siempre se realiza por bloques.
1157 de los datos siempre se realiza por bloques.
1089 """
1158 """
1090 __configHeaderFile = 'wrSetHeadet.txt'
1159 __configHeaderFile = 'wrSetHeadet.txt'
1091
1160
1092 def __init__( self, m_Voltage = None ):
1161 def __init__(self,m_Voltage=None):
1093 """
1162 """
1094 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1163 Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
1095
1164
1096 Affected:
1165 Affected:
1097 self.m_Voltage
1166 self.m_Voltage
1098 self.m_BasicHeader
1167 self.m_BasicHeader
1099 self.m_SystemHeader
1168 self.m_SystemHeader
1100 self.m_RadarControllerHeader
1169 self.m_RadarControllerHeader
1101 self.m_ProcessingHeader
1170 self.m_ProcessingHeader
1102
1171
1103 Return: None
1172 Return: None
1104 """
1173 """
1105 if m_Voltage == None:
1174 if m_Voltage == None:
1106 m_Voltage = Voltage()
1175 m_Voltage = Voltage()
1107
1176
1108 self.m_Voltage = m_Voltage
1177 self.m_Voltage = m_Voltage
1109
1178
1110 self.__path = None
1179 self.__path = None
1111
1180
1112 self.__fp = None
1181 self.__fp = None
1113
1182
1114 self.__format = None
1183 self.__format = None
1115
1184
1116 self.__blocksCounter = 0
1185 self.__blocksCounter = 0
1117
1186
1118 self.__setFile = None
1187 self.__setFile = None
1119
1188
1120 self.__flagIsNewFile = 1
1189 self.__flagIsNewFile = 1
1121
1190
1122 self.datablock = None
1191 self.datablock = None
1123
1192
1124 self.__datablockIndex = 0
1193 self.__datablockIndex = 0
1125
1194
1126 self.__dataType = None
1195 self.__dataType = None
1127
1196
1128 self.__ext = None
1197 self.__ext = None
1129
1198
1130 self.__shapeBuffer = None
1199 self.__shapeBuffer = None
1131
1200
1132 self.nWriteBlocks = 0
1201 self.nWriteBlocks = 0
1133
1202
1134 self.flagIsNewBlock = 0
1203 self.flagIsNewBlock = 0
1135
1204
1136 self.noMoreFiles = 0
1205 self.noMoreFiles = 0
1137
1206
1138 self.filename = None
1207 self.filename = None
1139
1208
1140 self.m_BasicHeader= BasicHeader()
1209 self.m_BasicHeader= BasicHeader()
1141
1210
1142 self.m_SystemHeader = SystemHeader()
1211 self.m_SystemHeader = SystemHeader()
1143
1212
1144 self.m_RadarControllerHeader = RadarControllerHeader()
1213 self.m_RadarControllerHeader = RadarControllerHeader()
1145
1214
1146 self.m_ProcessingHeader = ProcessingHeader()
1215 self.m_ProcessingHeader = ProcessingHeader()
1147
1216
1148
1217
1149 def __writeFirstHeader( self ):
1218 def __writeFirstHeader(self):
1150 """
1219 """
1151 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1220 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1152
1221
1153 Affected:
1222 Affected:
1154 __dataType
1223 __dataType
1155
1224
1156 Return:
1225 Return:
1157 None
1226 None
1158 """
1227 """
1159 self.__writeBasicHeader()
1228 self.__writeBasicHeader()
1160 self.__wrSystemHeader()
1229 self.__wrSystemHeader()
1161 self.__wrRadarControllerHeader()
1230 self.__wrRadarControllerHeader()
1162 self.__wrProcessingHeader()
1231 self.__wrProcessingHeader()
1163 self.__dataType = self.m_Voltage.dataType
1232 self.__dataType = self.m_Voltage.dataType
1164
1233
1165
1234
1166 def __writeBasicHeader( self, fp=None ):
1235 def __writeBasicHeader(self,fp=None):
1167 """
1236 """
1168 Escribe solo el Basic header en el file creado
1237 Escribe solo el Basic header en el file creado
1169
1238
1170 Return:
1239 Return:
1171 None
1240 None
1172 """
1241 """
1173 if fp == None:
1242 if fp == None:
1174 fp = self.__fp
1243 fp = self.__fp
1175
1244
1176 self.m_BasicHeader.write(fp)
1245 self.m_BasicHeader.write(fp)
1177
1246
1178
1247
1179 def __wrSystemHeader( self, fp=None ):
1248 def __wrSystemHeader(self,fp=None):
1180 """
1249 """
1181 Escribe solo el System header en el file creado
1250 Escribe solo el System header en el file creado
1182
1251
1183 Return:
1252 Return:
1184 None
1253 None
1185 """
1254 """
1186 if fp == None:
1255 if fp == None:
1187 fp = self.__fp
1256 fp = self.__fp
1188
1257
1189 self.m_SystemHeader.write(fp)
1258 self.m_SystemHeader.write(fp)
1190
1259
1191
1260
1192 def __wrRadarControllerHeader( self, fp=None ):
1261 def __wrRadarControllerHeader(self,fp=None):
1193 """
1262 """
1194 Escribe solo el RadarController header en el file creado
1263 Escribe solo el RadarController header en el file creado
1195
1264
1196 Return:
1265 Return:
1197 None
1266 None
1198 """
1267 """
1199 if fp == None:
1268 if fp == None:
1200 fp = self.__fp
1269 fp = self.__fp
1201
1270
1202 self.m_RadarControllerHeader.write(fp)
1271 self.m_RadarControllerHeader.write(fp)
1203
1272
1204
1273
1205 def __wrProcessingHeader( self, fp=None ):
1274 def __wrProcessingHeader(self,fp=None):
1206 """
1275 """
1207 Escribe solo el Processing header en el file creado
1276 Escribe solo el Processing header en el file creado
1208
1277
1209 Return:
1278 Return:
1210 None
1279 None
1211 """
1280 """
1212 if fp == None:
1281 if fp == None:
1213 fp = self.__fp
1282 fp = self.__fp
1214
1283
1215 self.m_ProcessingHeader.write(fp)
1284 self.m_ProcessingHeader.write(fp)
1216
1285
1217 def __setNextFile( self ):
1286
1287 def __setNextFile(self):
1218 """
1288 """
1219 Determina el siguiente file que sera escrito
1289 Determina el siguiente file que sera escrito
1220
1290
1221 Affected:
1291 Affected:
1222 self.filename
1292 self.filename
1223 self.__subfolder
1293 self.__subfolder
1224 self.__fp
1294 self.__fp
1225 self.__setFile
1295 self.__setFile
1226 self.__flagIsNewFile
1296 self.__flagIsNewFile
1227
1297
1228 Return:
1298 Return:
1229 0 : Si el archivo no puede ser escrito
1299 0 : Si el archivo no puede ser escrito
1230 1 : Si el archivo esta listo para ser escrito
1300 1 : Si el archivo esta listo para ser escrito
1231 """
1301 """
1232 #setFile = self.__setFile
1302 #setFile = self.__setFile
1233 ext = self.__ext
1303 ext = self.__ext
1234 path = self.__path
1304 path = self.__path
1235
1305
1236 #setFile += 1
1306 #setFile += 1
1237
1307
1238 if self.__fp != None:
1308 if self.__fp != None:
1239 self.__fp.close()
1309 self.__fp.close()
1240
1310
1241 """
1311 """
1242 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
1312 timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
1243 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
1313 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
1244 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1314 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1245 tmp = os.path.join(path,subfolder)
1315 tmp = os.path.join(path,subfolder)
1246 if not(os.path.exists(tmp)):
1316 if not(os.path.exists(tmp)):
1247 os.mkdir(tmp)
1317 os.mkdir(tmp)
1248 """
1318 """
1249 ##################################
1319 ##################################
1250 if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1320 """
1321 if self.m_BasicHeader.size <= 24:
1322 self.__fp.close()
1323 self.__fp = None
1324 return 0 #no existe la suficiente data para ser escrita
1325 """
1251
1326
1252 timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
1327 timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
1253 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1328 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1254
1329
1255 tmp = os.path.join( path, subfolder )
1330 tmp = os.path.join( path, subfolder )
1256 if not( os.path.exists(tmp) ):
1331 if not( os.path.exists(tmp) ):
1257 os.mkdir(tmp)
1332 os.mkdir(tmp)
1258 self.__setFile = -1 #inicializo mi contador de seteo
1333 self.__setFile = -1 #inicializo mi contador de seteo
1259 else:
1334 else:
1260 filesList = os.listdir( tmp )
1335 filesList = os.listdir( tmp )
1261 if len( filesList ) > 0:
1336 if len( filesList ) > 0:
1262 filesList = sorted( filesList, key=str.lower )
1337 filesList = sorted( filesList, key=str.lower )
1263 filen = filesList[-1]
1338 filen = filesList[-1]
1264 # el filename debera tener el siguiente formato
1339 # el filename debera tener el siguiente formato
1265 # 0 1234 567 89A BCDE (hex)
1340 # 0 1234 567 89A BCDE (hex)
1266 # D YYYY DDD SSS .ext
1341 # D YYYY DDD SSS .ext
1267 if isNumber( filen[8:11] ):
1342 if isNumber( filen[8:11] ):
1268 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1343 self.__setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1269 else:
1344 else:
1270 self.__setFile = -1
1345 self.__setFile = -1
1271 else:
1346 else:
1272 self.__setFile = -1 #inicializo mi contador de seteo
1347 self.__setFile = -1 #inicializo mi contador de seteo
1273
1348
1274 setFile = self.__setFile
1349 setFile = self.__setFile
1275 setFile += 1
1350 setFile += 1
1276 file = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1351 file = 'D%4.4d%3.3d%3.3d%s' % ( timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1277 ##################################
1352 ##################################
1278
1353
1279 filename = os.path.join( path, subfolder, file )
1354 filename = os.path.join( path, subfolder, file )
1280
1355
1281 fp = open( filename,'wb' )
1356 fp = open( filename,'wb' )
1282
1357
1283 self.__blocksCounter = 0
1358 self.__blocksCounter = 0
1284
1359
1285 #guardando atributos
1360 #guardando atributos
1286 self.filename = filename
1361 self.filename = filename
1287 self.__subfolder = subfolder
1362 self.__subfolder = subfolder
1288 self.__fp = fp
1363 self.__fp = fp
1289 self.__setFile = setFile
1364 self.__setFile = setFile
1290 self.__flagIsNewFile = 1
1365 self.__flagIsNewFile = 1
1291
1366
1292 print 'Writing the file: %s'%self.filename
1367 print 'Writing the file: %s'%self.filename
1293
1368
1294 self.__writeFirstHeader()
1369 self.__writeFirstHeader()
1295
1370
1296 return 1
1371 return 1
1297
1372
1298
1373
1299 def __setNewBlock( self ):
1374 def __setNewBlock(self):
1300 """
1375 """
1301 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1376 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1302
1377
1303 Return:
1378 Return:
1304 0 : si no pudo escribir nada
1379 0 : si no pudo escribir nada
1305 1 : Si escribio el Basic el First Header
1380 1 : Si escribio el Basic el First Header
1306 """
1381 """
1307 if self.__fp == None:
1382 if self.__fp == None:
1308 self.__setNextFile()
1383 self.__setNextFile()
1309
1384
1310 if self.__flagIsNewFile:
1385 if self.__flagIsNewFile:
1311 return 1
1386 return 1
1312
1387
1313 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1388 if self.__blocksCounter < self.m_ProcessingHeader.dataBlocksPerFile:
1314 self.__writeBasicHeader()
1389 self.__writeBasicHeader()
1315 return 1
1390 return 1
1316
1391
1317 if not( self.__setNextFile() ):
1392 if not( self.__setNextFile() ):
1318 return 0
1393 return 0
1319
1394
1320 return 1
1395 return 1
1321
1396
1322 def __writeBlock( self ):
1397
1398 def __writeBlock(self):
1323 """
1399 """
1324 Escribe el buffer en el file designado
1400 Escribe el buffer en el file designado
1325
1401
1326 Affected:
1402 Affected:
1327 self.__datablockIndex
1403 self.__datablockIndex
1328 self.__flagIsNewFile
1404 self.__flagIsNewFile
1329 self.flagIsNewBlock
1405 self.flagIsNewBlock
1330 self.nWriteBlocks
1406 self.nWriteBlocks
1331 self.__blocksCounter
1407 self.__blocksCounter
1332
1408
1333 Return: None
1409 Return: None
1334 """
1410 """
1335 data = numpy.zeros( self.__shapeBuffer, self.__dataType )
1411 data = numpy.zeros( self.__shapeBuffer, self.__dataType )
1336
1412
1337 data['real'] = self.datablock.real
1413 data['real'] = self.datablock.real
1338 data['imag'] = self.datablock.imag
1414 data['imag'] = self.datablock.imag
1339
1415
1340 data = data.reshape( (-1) )
1416 data = data.reshape( (-1) )
1341
1417
1342 data.tofile( self.__fp )
1418 data.tofile( self.__fp )
1343
1419
1344 self.datablock.fill(0)
1420 self.datablock.fill(0)
1345
1346 self.__datablockIndex = 0
1421 self.__datablockIndex = 0
1347
1348 self.__flagIsNewFile = 0
1422 self.__flagIsNewFile = 0
1349
1350 self.flagIsNewBlock = 1
1423 self.flagIsNewBlock = 1
1351
1352 self.nWriteBlocks += 1
1424 self.nWriteBlocks += 1
1353
1354 self.__blocksCounter += 1
1425 self.__blocksCounter += 1
1355
1426
1356
1427
1357 def writeNextBlock( self ):
1428 def writeNextBlock(self):
1358 """
1429 """
1359 Selecciona el bloque siguiente de datos y los escribe en un file
1430 Selecciona el bloque siguiente de datos y los escribe en un file
1360
1431
1361 Return:
1432 Return:
1362 0 : Si no hizo pudo escribir el bloque de datos
1433 0 : Si no hizo pudo escribir el bloque de datos
1363 1 : Si no pudo escribir el bloque de datos
1434 1 : Si no pudo escribir el bloque de datos
1364 """
1435 """
1365 if not(self.__setNewBlock()):
1436 if not(self.__setNewBlock()):
1366 return 0
1437 return 0
1367
1438
1368 self.__writeBlock()
1439 self.__writeBlock()
1369
1370 return 1
1440 return 1
1371
1441
1372
1442
1373 def __hasAllDataInBuffer( self ):
1443 def __hasAllDataInBuffer(self):
1374 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
1444 if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
1375 return 1
1445 return 1
1376
1377 return 0
1446 return 0
1378
1447
1379
1448
1380 def putData( self ):
1449 def putData(self):
1381 """
1450 """
1382 Setea un bloque de datos y luego los escribe en un file
1451 Setea un bloque de datos y luego los escribe en un file
1383
1452
1384 Affected:
1453 Affected:
1385 self.flagIsNewBlock
1454 self.flagIsNewBlock
1386 self.__datablockIndex
1455 self.__datablockIndex
1387
1456
1388 Return:
1457 Return:
1389 0 : Si no hay data o no hay mas files que puedan escribirse
1458 0 : Si no hay data o no hay mas files que puedan escribirse
1390 1 : Si se escribio la data de un bloque en un file
1459 1 : Si se escribio la data de un bloque en un file
1391 """
1460 """
1392 self.flagIsNewBlock = 0
1461 self.flagIsNewBlock = 0
1393
1462
1394 if self.m_Voltage.flagNoData:
1463 if self.m_Voltage.flagNoData:
1395 return 0
1464 return 0
1396
1465
1397 if self.m_Voltage.flagResetProcessing:
1466 if self.m_Voltage.flagResetProcessing:
1398
1467
1399 self.datablock.fill(0)
1468 self.datablock.fill(0)
1400
1401 self.__datablockIndex = 0
1469 self.__datablockIndex = 0
1402 self.__setNextFile()
1470 self.__setNextFile()
1403
1471
1404 self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
1472 self.datablock[self.__datablockIndex,:,:] = self.m_Voltage.data
1405
1473
1406 self.__datablockIndex += 1
1474 self.__datablockIndex += 1
1407
1475
1408 if self.__hasAllDataInBuffer():
1476 if self.__hasAllDataInBuffer():
1409
1410 self.__getHeader()
1477 self.__getHeader()
1411 self.writeNextBlock()
1478 self.writeNextBlock()
1412
1479
1413 if self.noMoreFiles:
1480 if self.noMoreFiles:
1414 #print 'Process finished'
1481 #print 'Process finished'
1415 return 0
1482 return 0
1416
1483
1417 return 1
1484 return 1
1418
1485
1419
1486
1420 def __getHeader( self ):
1487 def __getHeader(self):
1421 """
1488 """
1422 Obtiene una copia del First Header
1489 Obtiene una copia del First Header
1423
1490
1424 Affected:
1491 Affected:
1425 self.m_BasicHeader
1492 self.m_BasicHeader
1426 self.m_SystemHeader
1493 self.m_SystemHeader
1427 self.m_RadarControllerHeader
1494 self.m_RadarControllerHeader
1428 self.m_ProcessingHeader
1495 self.m_ProcessingHeader
1429 self.__dataType
1496 self.__dataType
1430
1497
1431 Return:
1498 Return:
1432 None
1499 None
1433 """
1500 """
1434 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
1501 self.m_BasicHeader = self.m_Voltage.m_BasicHeader.copy()
1435 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
1502 self.m_SystemHeader = self.m_Voltage.m_SystemHeader.copy()
1436 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
1503 self.m_RadarControllerHeader = self.m_Voltage.m_RadarControllerHeader.copy()
1437 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
1504 self.m_ProcessingHeader = self.m_Voltage.m_ProcessingHeader.copy()
1438 self.__dataType = self.m_Voltage.dataType
1505 self.__dataType = self.m_Voltage.dataType
1439
1506
1440
1507
1441 def __setHeaderByFile( self ):
1508 def __setHeaderByFile(self):
1442
1509
1443 format = self.__format
1510 format = self.__format
1444 header = ['Basic','System','RadarController','Processing']
1511 header = ['Basic','System','RadarController','Processing']
1445
1512
1446 fmtFromFile = None
1513 fmtFromFile = None
1447 headerFromFile = None
1514 headerFromFile = None
1448
1515
1449
1516
1450 fileTable = self.__configHeaderFile
1517 fileTable = self.__configHeaderFile
1451
1518
1452 if os.access(fileTable, os.R_OK):
1519 if os.access(fileTable, os.R_OK):
1453 import re, string
1520 import re, string
1454
1521
1455 f = open(fileTable,'r')
1522 f = open(fileTable,'r')
1456 lines = f.read()
1523 lines = f.read()
1457 f.close()
1524 f.close()
1458
1525
1459 #Delete comments into expConfig
1526 #Delete comments into expConfig
1460 while 1:
1527 while 1:
1461
1528
1462 startComment = string.find(lines.lower(),'#')
1529 startComment = string.find(lines.lower(),'#')
1463 if startComment == -1:
1530 if startComment == -1:
1464 break
1531 break
1465 endComment = string.find(lines.lower(),'\n',startComment)
1532 endComment = string.find(lines.lower(),'\n',startComment)
1466 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1533 lines = string.replace(lines,lines[startComment:endComment+1],'', 1)
1467
1534
1468 while expFromFile == None:
1535 while expFromFile == None:
1469
1536
1470 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1537 currFmt = string.find(lines.lower(),'format="%s"' %(expName))
1471 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1538 nextFmt = string.find(lines.lower(),'format',currFmt+10)
1472
1539
1473 if currFmt == -1:
1540 if currFmt == -1:
1474 break
1541 break
1475 if nextFmt == -1:
1542 if nextFmt == -1:
1476 nextFmt = len(lines)-1
1543 nextFmt = len(lines)-1
1477
1544
1478 fmtTable = lines[currFmt:nextFmt]
1545 fmtTable = lines[currFmt:nextFmt]
1479 lines = lines[nextFmt:]
1546 lines = lines[nextFmt:]
1480
1547
1481 fmtRead = self.__getValueFromArg(fmtTable,'format')
1548 fmtRead = self.__getValueFromArg(fmtTable,'format')
1482 if fmtRead != format:
1549 if fmtRead != format:
1483 continue
1550 continue
1484 fmtFromFile = fmtRead
1551 fmtFromFile = fmtRead
1485
1552
1486 lines2 = fmtTable
1553 lines2 = fmtTable
1487
1554
1488 while headerFromFile == None:
1555 while headerFromFile == None:
1489
1556
1490 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1557 currHeader = string.find(lines2.lower(),'header="%s"' %(header))
1491 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1558 nextHeader = string.find(lines2.lower(),'header',currHeader+10)
1492
1559
1493 if currHeader == -1:
1560 if currHeader == -1:
1494 break
1561 break
1495 if nextHeader == -1:
1562 if nextHeader == -1:
1496 nextHeader = len(lines2)-1
1563 nextHeader = len(lines2)-1
1497
1564
1498 headerTable = lines2[currHeader:nextHeader]
1565 headerTable = lines2[currHeader:nextHeader]
1499 lines2 = lines2[nextHeader:]
1566 lines2 = lines2[nextHeader:]
1500
1567
1501 headerRead = self.__getValueFromArg(headerTable,'site')
1568 headerRead = self.__getValueFromArg(headerTable,'site')
1502 if not(headerRead in header):
1569 if not(headerRead in header):
1503 continue
1570 continue
1504 headerFromFile = headerRead
1571 headerFromFile = headerRead
1505
1572
1506 if headerRead == 'Basic':
1573 if headerRead == 'Basic':
1507 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1574 self.m_BasicHeader.size = self.__getValueFromArg(headerTable,'size',lower=False)
1508 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1575 self.m_BasicHeader.version = self.__getValueFromArg(headerTable,'version',lower=False)
1509 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1576 self.m_BasicHeader.dataBlock = self.__getValueFromArg(headerTable,'dataBlock',lower=False)
1510 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1577 self.m_BasicHeader.utc = self.__getValueFromArg(headerTable,'utc',lower=False)
1511 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1578 self.m_BasicHeader.miliSecond = self.__getValueFromArg(headerTable,'miliSecond',lower=False)
1512 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1579 self.m_BasicHeader.timeZone = self.__getValueFromArg(headerTable,'timeZone',lower=False)
1513 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1580 self.m_BasicHeader.dstFlag = self.__getValueFromArg(headerTable,'dstFlag',lower=False)
1514 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1581 self.m_BasicHeader.errorCount = self.__getValueFromArg(headerTable,'errorCount',lower=False)
1515
1582
1516 else:
1583 else:
1517 print "file access denied:%s"%fileTable
1584 print "file access denied:%s"%fileTable
1518 sys.exit(0)
1585 sys.exit(0)
1519
1586
1520
1587
1521 def setup( self, path, set=0, format='rawdata' ):
1588 def setup(self,path,set=0,format='rawdata'):
1522 """
1589 """
1523 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1590 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1524
1591
1525 Inputs:
1592 Inputs:
1526 path : el path destino en el cual se escribiran los files a crear
1593 path : el path destino en el cual se escribiran los files a crear
1527 format : formato en el cual sera salvado un file
1594 format : formato en el cual sera salvado un file
1528 set : el setebo del file
1595 set : el setebo del file
1529
1596
1530 Return:
1597 Return:
1531 0 : Si no realizo un buen seteo
1598 0 : Si no realizo un buen seteo
1532 1 : Si realizo un buen seteo
1599 1 : Si realizo un buen seteo
1533 """
1600 """
1534 if format == 'hdf5':
1601 if format == 'hdf5':
1535 ext = '.hdf5'
1602 ext = '.hdf5'
1536 format = 'hdf5'
1603 format = 'hdf5'
1537 print 'call hdf5 library'
1604 print 'call hdf5 library'
1538 return 0
1605 return 0
1539
1606
1540 if format == 'rawdata':
1607 if format == 'rawdata':
1541 ext = '.r'
1608 ext = '.r'
1542 format = 'Jicamarca'
1609 format = 'Jicamarca'
1543
1610
1544 #call to config_headers
1611 #call to config_headers
1545 #self.__setHeaderByFile()
1612 #self.__setHeaderByFile()
1546
1613
1547 self.__path = path
1614 self.__path = path
1548 self.__setFile = set - 1
1615 self.__setFile = set - 1
1549 self.__ext = ext
1616 self.__ext = ext
1550 self.__format = format
1617 self.__format = format
1551
1618
1552 self.__getHeader()
1619 self.__getHeader()
1553 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
1620 self.__shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
1554 self.m_ProcessingHeader.numHeights,
1621 self.m_ProcessingHeader.numHeights,
1555 self.m_SystemHeader.numChannels )
1622 self.m_SystemHeader.numChannels )
1556
1623
1557 self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
1624 self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
1558
1625
1559 # if not(self.__setNextFile()):
1626 if not( self.__setNextFile() ):
1560 # return 0
1627 return 0
1628
1561 return 1
1629 return 1
1562
1630
1563
1631
1564
1632
1565
1633
1566 No newline at end of file
1634
General Comments 0
You need to be logged in to leave comments. Login now