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