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