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