##// END OF EJS Templates
schain
RSS
SpectraIO.py: Salto de archivos online ha sido agregado
Miguel Valdez -
r29:ff31b7b057ae
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1051 +1,925
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 isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
24 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
26 """
25 """
27 Desc :
28 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
26 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
29 o no dentro del rango de fecha especificado.
27 o no dentro del rango de fecha especificado.
30
28
31 Inputs :
29 Inputs:
32 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
30 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
33
31
34 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
32 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
35 segundos contados desde 01/01/1970.
33 segundos contados desde 01/01/1970.
36
37 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
34 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
38 segundos contados desde 01/01/1970.
35 segundos contados desde 01/01/1970.
39
36
40 Return :
37 Return:
41 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
38 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
42 fecha especificado, de lo contrario retorna False.
39 fecha especificado, de lo contrario retorna False.
43
40
44 Excepciones :
41 Excepciones:
45 Si el archivo no existe o no puede ser abierto
42 Si el archivo no existe o no puede ser abierto
46 Si la cabecera no puede ser leida.
43 Si la cabecera no puede ser leida.
44
47 """
45 """
48 m_BasicHeader = BasicHeader()
46 m_BasicHeader = BasicHeader()
49
47
50 try:
48 try:
51 fp = open( filename,'rb' ) #lectura binaria
49 fp = open(filename,'rb')
52 except:
50 except:
53 raise IOError, "The file %s can't be opened" %(filename)
51 raise IOError, "The file %s can't be opened" %(filename)
54
52
55 if not(m_BasicHeader.read(fp)):
53 if not(m_BasicHeader.read(fp)):
56 raise IOError, "The file %s has not a valid header" %(filename)
54 raise IOError, "The file %s has not a valid header" %(filename)
57
55
58 fp.close()
56 fp.close()
59
57
60 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
58 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
61 return 0
59 return 0
62
60
63 return 1
61 return 1
64
62
65
63
66 class SpectraReader( DataReader ):
64 class SpectraReader(DataReader):
67 """
65 """
68 Desc :
69 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
66 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
70 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
67 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
71 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
68 perfiless*alturas*canales) son almacenados en la variable "buffer".
72
69
73 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
70 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
74 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
71 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
75 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
72 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
76 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
73 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
77
74
78 Example :
75 Example:
76
79 dpath = "/home/myuser/data"
77 dpath = "/home/myuser/data"
80
78
81 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
79 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
82
80
83 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
81 endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
84
82
85 readerObj = SpectraReader()
83 readerObj = SpectraReader()
86
84
87 readerObj.setup(dpath, startTime, endTime)
85 readerObj.setup(dpath, startTime, endTime)
88
86
89 while(True):
87 while(True):
90
88
91 readerObj.getData()
89 readerObj.getData()
92
90
93 print readerObj.m_Spectra.data
91 print readerObj.m_Spectra.data
94
92
95 if readerObj.noMoreFiles:
93 if readerObj.noMoreFiles:
96 break
94 break
97
95
98 """
96 """
99
97
100 #speed of light
98 #speed of light
101 __c = 3E8
99 __c = 3E8
102
100
103
104 def __init__( self, m_Spectra = None ):
101 def __init__( self, m_Spectra = None ):
105 """
102 """
106 Desc :
107 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
103 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
108
104
109 Inputs :
105 Input:
110 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
106 m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
111 almacenar un perfil de datos cada vez que se haga un requerimiento
107 almacenar un perfil de datos cada vez que se haga un requerimiento
112 (getData). El perfil sera obtenido a partir del buffer de datos,
108 (getData). El perfil sera obtenido a partir del buffer de datos,
113 si el buffer esta vacio se hara un nuevo proceso de lectura de un
109 si el buffer esta vacio se hara un nuevo proceso de lectura de un
114 bloque de datos.
110 bloque de datos.
115 Si este parametro no es pasado se creara uno internamente.
111 Si este parametro no es pasado se creara uno internamente.
116
112
117 Affected :
113 Variables afectadas:
118 self.m_Spectra
114 self.m_Spectra
119 self.m_BasicHeader
115 self.m_BasicHeader
120 self.m_SystemHeader
116 self.m_SystemHeader
121 self.m_RadarControllerHeader
117 self.m_RadarControllerHeader
122 self.m_ProcessingHeader
118 self.m_ProcessingHeader
123
119
124 Return : Nada
120
121 Return:
122 Void
123
125 """
124 """
126 if m_Spectra == None:
125 if m_Spectra == None:
127 m_Spectra = Spectra()
126 m_Spectra = Spectra()
128
127
129 if not( isinstance(m_Spectra, Spectra) ):
128 if not( isinstance(m_Spectra, Spectra) ):
130 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
129 raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
131
130
132 self.m_Spectra = m_Spectra
131 self.m_Spectra = m_Spectra
133
132
134 self.m_BasicHeader = BasicHeader()
133 self.m_BasicHeader = BasicHeader()
135
134
136 self.m_SystemHeader = SystemHeader()
135 self.m_SystemHeader = SystemHeader()
137
136
138 self.m_RadarControllerHeader = RadarControllerHeader()
137 self.m_RadarControllerHeader = RadarControllerHeader()
139
138
140 self.m_ProcessingHeader = ProcessingHeader()
139 self.m_ProcessingHeader = ProcessingHeader()
141
140
142 self.__fp = None
141 self.__fp = None
143
142
144 self.__idFile = None
143 self.__idFile = None
145
144
146 self.__startDateTime = None
145 self.__startDateTime = None
147
146
148 self.__endDateTime = None
147 self.__endDateTime = None
149
148
150 self.__dataType = None
149 self.__dataType = None
151
150
152 self.__fileSizeByHeader = 0
151 self.__fileSizeByHeader = 0
153
152
154 self.__pathList = []
153 self.__pathList = []
155
154
156 self.filenameList = []
155 self.filenameList = []
157
156
158 self.__lastUTTime = 0
157 self.__lastUTTime = 0
159
158
160 self.__maxTimeStep = 30
159 self.__maxTimeStep = 30
161
160
162 self.__flagIsNewFile = 0
161 self.__flagIsNewFile = 0
163
162
164 self.flagResetProcessing = 0
163 self.flagResetProcessing = 0
165
164
166 self.flagIsNewBlock = 0
165 self.flagIsNewBlock = 0
167
166
168 self.noMoreFiles = 0
167 self.noMoreFiles = 0
169
168
170 self.nReadBlocks = 0
169 self.nReadBlocks = 0
171
170
172 self.online = 0
171 self.online = 0
173
172
174 self.firstHeaderSize = 0
173 self.firstHeaderSize = 0
175
174
176 self.basicHeaderSize = 24
175 self.basicHeaderSize = 24
177
176
178 self.filename = None
177 self.filename = None
179
178
180 self.fileSize = None
179 self.fileSize = None
181
180
182 self.__buffer_spc = None
181 self.__buffer_spc = None
183 self.__buffer_cspc = None
182 self.__buffer_cspc = None
184 self.__buffer_dc = None
183 self.__buffer_dc = None
185
184
186 self.Npair_SelfSpectra = 0
187 self.Npair_CrossSpectra = 0
188
189 self.pts2read_SelfSpectra = 0
190 self.pts2read_CrossSpectra = 0
191
192 self.__buffer_id = 0
185 self.__buffer_id = 0
193
186
194 self.__ippSeconds = 0
187 self.__ippSeconds = 0
195
188
196 self.nSelfChannels = 0
189 self.nSelfChannels = 0
197
190
198 self.nCrossPairs = 0
191 self.nCrossPairs = 0
199
192
200 self.nChannels = 0
193 self.nChannels = 0
201
194
195 self.__path = None
196 self.__startDateTime = None
197 self.__endDateTime = None
198 self.__expLabel = None
199 self.__set = None
200 self.__ext = None
202
201
203 def __rdSystemHeader( self, fp=None ):
202 def __rdSystemHeader( self, fp=None ):
204 """
205 Desc :
206 Lectura del System Header
207
208 Inputs :
209 fp : file pointer
210
211 Affected : Nada
212 self.m_SystemHeader
213
214 Return : Nada
215 """
216 if fp == None:
203 if fp == None:
217 fp = self.__fp
204 fp = self.__fp
218
205
219 self.m_SystemHeader.read( fp )
206 self.m_SystemHeader.read( fp )
220
207
221
222 def __rdRadarControllerHeader( self, fp=None ):
208 def __rdRadarControllerHeader( self, fp=None ):
223 """
224 Desc :
225 Lectura del Radar Controller Header
226
227 Inputs :
228 fp : file pointer
229
230 Affected :
231 self.m_RadarControllerHeader
232
233 Return : Nada
234 """
235 if fp == None:
209 if fp == None:
236 fp = self.__fp
210 fp = self.__fp
237
211
238 self.m_RadarControllerHeader.read(fp)
212 self.m_RadarControllerHeader.read(fp)
239
213
240
241 def __rdProcessingHeader( self,fp=None ):
214 def __rdProcessingHeader( self,fp=None ):
242 """
243 Desc :
244 Lectura del Processing Header
245
246 Inputs :
247 fp : file pointer
248
249 Affected :
250 self.m_ProcessingHeader
251
252 Return : Nada
253 """
254 if fp == None:
215 if fp == None:
255 fp = self.__fp
216 fp = self.__fp
256
217
257 self.m_ProcessingHeader.read(fp)
218 self.m_ProcessingHeader.read(fp)
258
219
259
260 def __rdBasicHeader( self, fp=None ):
220 def __rdBasicHeader( self, fp=None ):
261 """
262 Desc :
263 Lectura del Basic Header
264
265 Inputs :
266 fp : file pointer
267
268 Affected :
269 self.m_BasicHeader
270
271 Return : Nada
272 """
273 if fp == None:
221 if fp == None:
274 fp = self.__fp
222 fp = self.__fp
275
223
276 self.m_BasicHeader.read(fp)
224 self.m_BasicHeader.read(fp)
277
225
278
279 def __readFirstHeader( self ):
226 def __readFirstHeader( self ):
280 """
281 Desc :
282 Lectura del First Header, es decir el Basic Header y el Long Header
283
284 Affected : Nada
285 self.m_BasicHeader
286 self.m_SystemHeader
287 self.m_RadarControllerHeader
288 self.m_ProcessingHeader
289 self.firstHeaderSize
290 self.__heights
291 self.__dataType
292 self.__fileSizeByHeader
293 self.__ippSeconds
294 self.Npair_SelfSpectra
295 self.Npair_CrossSpectra
296 self.pts2read_SelfSpectra
297 self.pts2read_CrossSpectra
298
299 Return : None
300 """
301 self.__rdBasicHeader()
227 self.__rdBasicHeader()
302 self.__rdSystemHeader()
228 self.__rdSystemHeader()
303 self.__rdRadarControllerHeader()
229 self.__rdRadarControllerHeader()
304 self.__rdProcessingHeader()
230 self.__rdProcessingHeader()
305 self.firstHeaderSize = self.m_BasicHeader.size
231 self.firstHeaderSize = self.m_BasicHeader.size
306
232
307 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
233 data_type = int( numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR) )
308 if data_type == 0:
234 if data_type == 0:
309 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
235 tmp = numpy.dtype([('real','<i1'),('imag','<i1')])
310
236
311 elif data_type == 1:
237 elif data_type == 1:
312 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
238 tmp = numpy.dtype([('real','<i2'),('imag','<i2')])
313
239
314 elif data_type == 2:
240 elif data_type == 2:
315 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
241 tmp = numpy.dtype([('real','<i4'),('imag','<i4')])
316
242
317 elif data_type == 3:
243 elif data_type == 3:
318 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
244 tmp = numpy.dtype([('real','<i8'),('imag','<i8')])
319
245
320 elif data_type == 4:
246 elif data_type == 4:
321 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
247 tmp = numpy.dtype([('real','<f4'),('imag','<f4')])
322
248
323 elif data_type == 5:
249 elif data_type == 5:
324 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
250 tmp = numpy.dtype([('real','<f8'),('imag','<f8')])
325
251
326 else:
252 else:
327 raise ValueError, 'Data type was not defined'
253 raise ValueError, 'Data type was not defined'
328
254
329 xi = self.m_ProcessingHeader.firstHeight
255 xi = self.m_ProcessingHeader.firstHeight
330 step = self.m_ProcessingHeader.deltaHeight
256 step = self.m_ProcessingHeader.deltaHeight
331 xf = xi + self.m_ProcessingHeader.numHeights*step
257 xf = xi + self.m_ProcessingHeader.numHeights*step
332
258
333 self.__heights = numpy.arange(xi, xf, step)
259 self.__heights = numpy.arange(xi, xf, step)
334 self.__dataType = tmp
260 self.__dataType = tmp
335 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
261 self.__fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
336 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
262 self.__ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp/self.__c
337
263
338 self.Npair_SelfSpectra = 0
264 def __setNextFileOnline(self, delay = 60 ):
339 self.Npair_CrossSpectra = 0
265 """
340
266
341 for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
342 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
343 self.Npair_SelfSpectra = self.Npair_SelfSpectra + 1
344 else:
345 self.Npair_CrossSpectra = self.Npair_CrossSpectra + 1
346
267
347 pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights
268 return:
348 self.pts2read_SelfSpectra = int( pts2read * self.Npair_SelfSpectra )
269 bool
349 self.pts2read_CrossSpectra = int( pts2read * self.Npair_CrossSpectra )
350
270
271 """
272 nFiles = 3
273 nTries = 3
351
274
352 def __setNextFileOnline( self ):
275 countFiles = 0
353 return 1
276 countTries = 0
354
277
278 fileStatus = False
355
279
356 def __setNextFileOffline( self ):
280 while(True):
357 """
281 countFiles += 1
358 Desc :
359 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
360
282
361 Affected :
283 if countFiles > nFiles+1:
362 self.__flagIsNewFile
284 break
363 self.__idFile
364 self.filename
365 self.fileSize
366 self.__fp
367
285
368 Return :
286 self.set += 1
369 0 : si un determinado file no puede ser abierto
370 1 : si el file fue abierto con exito
371
287
372 Excepciones :
288 if countFiles > nFiles:
373 Si un determinado file no puede ser abierto
289 self.doy += 1
374 """
290 self.set = 0
291
292 doypath = "D%04d%04d" %(self.year, self.doy)
293 filename = "D%04d%04d%03d%s" %(self.year, self.doy, self.set, self.__ext)
294 file = os.path.join(self.filepath, doypath, filename)
295 fileSize = os.path.getsize(file)
296
297 try:
298 fp = open(file)
299 except:
300 raise IOError, "The file %s can't be opened" %file
301
302 while(True):
303 countTries += 1
304 if countTries > nTries:
305 break
306
307 currentSize = fileSize - fp.tell()
308 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
309
310 if (currentSize < neededSize):
311 #waiting for this block
312 time.sleep(delay)
313 else:
314 fileStatus = True
315 break
316
317 if fileStatus:
318 break
319
320 print "Skipping the file %s due to it hasn't enough data" %filename
321 fp.close()
322
323 return fileStatus
324
325 def __setNextFileOffline( self ):
375 idFile = self.__idFile
326 idFile = self.__idFile
376
327
377 while(True):
328 while(True):
378 idFile += 1
329 idFile += 1
379
330
380 if not( idFile < len(self.filenameList) ):
331 if not( idFile < len(self.filenameList) ):
381 self.noMoreFiles = 1
332 self.noMoreFiles = 1
382 return 0
333 return 0
383
334
384 filename = self.filenameList[idFile]
335 filename = self.filenameList[idFile]
385 fileSize = os.path.getsize(filename)
336 fileSize = os.path.getsize(filename)
386
337
387 try:
338 try:
388 fp = open( filename, 'rb' )
339 fp = open( filename, 'rb' )
389 except:
340 except:
390 raise IOError, "The file %s can't be opened" %filename
341 raise IOError, "The file %s can't be opened" %filename
391
342
392 currentSize = fileSize - fp.tell()
343 currentSize = fileSize - fp.tell()
393 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
344 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
394
345
395 if (currentSize < neededSize):
346 if (currentSize < neededSize):
396 print "Skipping the file %s due to it hasn't enough data" %filename
347 print "Skipping the file %s due to it hasn't enough data" %filename
348 fp.close()
397 continue
349 continue
398
350
399 break
351 break
400
352
401 self.__flagIsNewFile = 1
353 self.__flagIsNewFile = 1
402 self.__idFile = idFile
354 self.__idFile = idFile
403 self.filename = filename
355 self.filename = filename
404 self.fileSize = fileSize
356 self.fileSize = fileSize
405 self.__fp = fp
357 self.__fp = fp
406
358
407 print 'Setting the file: %s'%self.filename
359 print 'Setting the file: %s'%self.filename
408
360
409 return 1
361 return 1
410
362
411
412 def __setNextFile( self ):
363 def __setNextFile(self):
413 """
414 Desc :
415 Determina el siguiente file a leer y si hay uno disponible lee el First Header
416
364
417 Affected :
365 if self.__fp != None:
418 self.m_BasicHeader
366 self.__fp.close()
419 self.m_SystemHeader
420 self.m_RadarControllerHeader
421 self.m_ProcessingHeader
422 self.firstHeaderSize
423
367
424 Return :
425 0 : Si no hay files disponibles
426 1 : Si hay mas files disponibles
427 """
428 if self.online:
368 if self.online:
429 newFile = self.__setNextFileOnline()
369 newFile = self.__setNextFileOnline()
430 else:
370 else:
431 newFile = self.__setNextFileOffline()
371 newFile = self.__setNextFileOffline()
432
372
433 if not(newFile):
373 if not(newFile):
434 return 0
374 return 0
435
375
436 self.__readFirstHeader()
376 self.__readFirstHeader()
437
377
438 return 1
378 return 1
439
379
440
441 def __setNewBlock( self ):
380 def __setNewBlock( self ):
442 """
443 Desc :
444 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
445
446 Affected :
447 self.flagResetProcessing
448 self.ns
449
450 Return :
451 0 : Si el file no tiene un Basic Header que pueda ser leido
452 1 : Si se pudo leer el Basic Header
453 """
454 if self.__fp == None:
381 if self.__fp == None:
455 return 0
382 return 0
456
383
457 if self.__flagIsNewFile:
384 if self.__flagIsNewFile:
458 return 1
385 return 1
459
386
460 currentSize = self.fileSize - self.__fp.tell()
387 currentSize = self.fileSize - self.__fp.tell()
461 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
388 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
462
389
463 #If there is enough data setting new data block
390 #If there is enough data setting new data block
464 if ( currentSize >= neededSize ):
391 if ( currentSize >= neededSize ):
465 self.__rdBasicHeader()
392 self.__rdBasicHeader()
466 return 1
393 return 1
467
394
468 #Setting new file
395 #Setting new file
469 if not( self.__setNextFile() ):
396 if not( self.__setNextFile() ):
470 return 0
397 return 0
471
398
472 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
399 deltaTime = self.m_BasicHeader.utc - self.__lastUTTime # check this
473
400
474 self.flagResetProcessing = 0
401 self.flagResetProcessing = 0
475
402
476 if deltaTime > self.__maxTimeStep:
403 if deltaTime > self.__maxTimeStep:
477 self.flagResetProcessing = 1
404 self.flagResetProcessing = 1
478 self.ns = 0
405 self.ns = 0
479
406
480 return 1
407 return 1
481
408
482
409
410
483 def __readBlock(self):
411 def __readBlock(self):
484 """
412 """
485 Desc :
486 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
413 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
487 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
414 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
488 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
415 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
489 es seteado a 0
416 es seteado a 0
490
417
418 Inputs:
419 None
420
491 Return:
421 Return:
492 None
422 None
493
423
494 Variables afectadas:
424 Variables afectadas:
425
495 self.__buffer_id
426 self.__buffer_id
427
428 self.__buffer_sspc
429
496 self.__flagIsNewFile
430 self.__flagIsNewFile
431
497 self.flagIsNewBlock
432 self.flagIsNewBlock
433
498 self.nReadBlocks
434 self.nReadBlocks
499 self.__buffer_spc
435
500 self.__buffer_cspc
501 self.__buffer_dc
502 """
436 """
437 Npair_SelfSpectra = 0
438 Npair_CrossSpectra = 0
439
440 for i in range( 0,self.m_ProcessingHeader.totalSpectra*2,2 ):
441 if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
442 Npair_SelfSpectra = Npair_SelfSpectra + 1
443 else:
444 Npair_CrossSpectra = Npair_CrossSpectra + 1
445
446 # self.__buffer_sspc = numpy.concatenate( (data_sspc,data_cspc,data_dcc), axis=0 )
447
503 self.__buffer_id = 0
448 self.__buffer_id = 0
504 self.__flagIsNewFile = 0
449 self.__flagIsNewFile = 0
505 self.flagIsNewBlock = 1
450 self.flagIsNewBlock = 1
506
451
507 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.pts2read_SelfSpectra )
452 pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights
508 cspc = numpy.fromfile( self.__fp, self.__dataType, self.pts2read_CrossSpectra )
509 dc = numpy.fromfile( self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
510
453
511 spc = spc.reshape( (self.Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
454 spc = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra))
455 cspc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra))
456 dc = numpy.fromfile(self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
512
457
513 cspc = cspc.reshape( (self.Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
458 spc = spc.reshape((Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
514 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
459 cspc = cspc.reshape((Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock))
460 dc = dc.reshape((self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights))
515
461
516 if not( self.m_ProcessingHeader.shif_fft ):
462 if not(self.m_ProcessingHeader.shif_fft):
517 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
463 spc = numpy.roll(spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
518 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
464 cspc = numpy.roll(cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
519
465
520 spc = numpy.transpose( spc, (0,2,1) )
466 spc = numpy.transpose(spc, (0,2,1))
521 cspc = numpy.transpose( cspc, (0,2,1) )
467 cspc = numpy.transpose(cspc, (0,2,1))
522 #dc = numpy.transpose(dc, (0,2,1))
468 #dc = numpy.transpose(dc, (0,2,1))
523
469
524 """
525 data_spc = spc
470 data_spc = spc
526 data_cspc = cspc['real'] + cspc['imag']*1j
471 data_cspc = cspc['real'] + cspc['imag']*1j
527 data_dc = dc['real'] + dc['imag']*1j
472 data_dc = dc['real'] + dc['imag']*1j
528
473
529 self.__buffer_spc = data_spc
474 self.__buffer_spc = data_spc
530 self.__buffer_cspc = data_cspc
475 self.__buffer_cspc = data_cspc
531 self.__buffer_dc = data_dc
476 self.__buffer_dc = data_dc
532 """
533 self.__buffer_spc = spc
534 self.__buffer_cspc = cspc['real'] + cspc['imag']*1j
535 self.__buffer_dc = dc['real'] + dc['imag']*1j
536
477
537 self.__flagIsNewFile = 0
478 self.__flagIsNewFile = 0
538
479
539 self.flagIsNewBlock = 1
480 self.flagIsNewBlock = 1
540
481
541 self.nReadBlocks += 1
482 self.nReadBlocks += 1
542
483
543
484
544 def __hasNotDataInBuffer( self ):
485 def __hasNotDataInBuffer(self):
545 return 1
486 return 1
546
487
488 def __searchFilesOnline(self, path, startDateTime, expLabel = "", ext = ".pdata"):
489 """
490
491
492 Return:
493
494 filepath
495
496 filename
497
498 year
499
500 doy
501
502 set
547
503
548 def __searchFiles( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
549 """
504 """
550 Desc :
505
506 pass
507
508 def __searchFilesOffline(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
509 """
551 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
510 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
552 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
511 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
553 correcta la estructura de directorios debe ser la siguiente:
512 correcta la estructura de directorios debe ser la siguiente:
554
513
555 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
514 ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
556
515
557 [yyyy]: anio
516 [yyyy]: anio
558 [ddd] : dia del anio
517 [ddd] : dia del anio
559 [sss] : set del archivo
518 [sss] : set del archivo
560
519
561 Inputs:
520 Inputs:
562 path : Directorio de datos donde se realizara la busqueda. Todos los
521 path : Directorio de datos donde se realizara la busqueda. Todos los
563 ficheros que concidan con el criterio de busqueda seran
522 ficheros que concidan con el criterio de busqueda seran
564 almacenados en una lista y luego retornados.
523 almacenados en una lista y luego retornados.
565 startDateTime : Fecha inicial. Rechaza todos los archivos donde
524 startDateTime : Fecha inicial. Rechaza todos los archivos donde
566 file end time < startDateTime (objeto datetime.datetime)
525 file end time < startDateTime (objeto datetime.datetime)
567
526
568 endDateTime : Fecha final. Rechaza todos los archivos donde
527 endDateTime : Fecha final. Rechaza todos los archivos donde
569 file start time > endDateTime (obejto datetime.datetime)
528 file start time > endDateTime (obejto datetime.datetime)
570
529
571 set : Set del primer archivo a leer. Por defecto None
530 set : Set del primer archivo a leer. Por defecto None
572
531
573 expLabel : Nombre del subdirectorio de datos. Por defecto ""
532 expLabel : Nombre del subdirectorio de datos. Por defecto ""
574
533
575 ext : Extension de los archivos a leer. Por defecto .r
534 ext : Extension de los archivos a leer. Por defecto .r
576
535
577 Return:
536 Return:
578
537
579 (pathList, filenameList)
538 (pathList, filenameList)
580
539
581 pathList : Lista de directorios donde se encontraron archivos dentro
540 pathList : Lista de directorios donde se encontraron archivos dentro
582 de los parametros especificados
541 de los parametros especificados
583 filenameList : Lista de archivos (ruta completa) que coincidieron con los
542 filenameList : Lista de archivos (ruta completa) que coincidieron con los
584 parametros especificados.
543 parametros especificados.
585
544
586 Variables afectadas:
545 Variables afectadas:
587
546
588 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
547 self.filenameList: Lista de archivos (ruta completa) que la clase utiliza
589 como fuente para leer los bloque de datos, si se termina
548 como fuente para leer los bloque de datos, si se termina
590 de leer todos los bloques de datos de un determinado
549 de leer todos los bloques de datos de un determinado
591 archivo se pasa al siguiente archivo de la lista.
550 archivo se pasa al siguiente archivo de la lista.
551
552 Excepciones:
553
592 """
554 """
593
555
594 print "Searching files ..."
556 print "Searching files ..."
595
557
596 dirList = []
558 dirList = []
597 for thisPath in os.listdir(path):
559 for thisPath in os.listdir(path):
598 if os.path.isdir(os.path.join(path,thisPath)):
560 if os.path.isdir(os.path.join(path,thisPath)):
599 dirList.append(thisPath)
561 dirList.append(thisPath)
600
562
601 pathList = []
563 pathList = []
602
564
603 thisDateTime = startDateTime
565 thisDateTime = startDateTime
604
566
605 while(thisDateTime <= endDateTime):
567 while(thisDateTime <= endDateTime):
606 year = thisDateTime.timetuple().tm_year
568 year = thisDateTime.timetuple().tm_year
607 doy = thisDateTime.timetuple().tm_yday
569 doy = thisDateTime.timetuple().tm_yday
608
570
609 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
571 match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
610 if len(match) == 0:
572 if len(match) == 0:
611 thisDateTime += datetime.timedelta(1)
573 thisDateTime += datetime.timedelta(1)
612 continue
574 continue
613
575
614 pathList.append(os.path.join(path,match[0],expLabel))
576 pathList.append(os.path.join(path,match[0],expLabel))
615 thisDateTime += datetime.timedelta(1)
577 thisDateTime += datetime.timedelta(1)
616
578
617 startUtSeconds = time.mktime(startDateTime.timetuple())
579 startUtSeconds = time.mktime(startDateTime.timetuple())
618 endUtSeconds = time.mktime(endDateTime.timetuple())
580 endUtSeconds = time.mktime(endDateTime.timetuple())
619
581
620 filenameList = []
582 filenameList = []
621 for thisPath in pathList:
583 for thisPath in pathList:
622 fileList = glob.glob1(thisPath, "*%s" %ext)
584 fileList = glob.glob1(thisPath, "*%s" %ext)
623 fileList.sort()
585 fileList.sort()
624 for file in fileList:
586 for file in fileList:
625 filename = os.path.join(thisPath,file)
587 filename = os.path.join(thisPath,file)
626 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
588 if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
627 filenameList.append(filename)
589 filenameList.append(filename)
628
590
629 self.filenameList = filenameList
591 self.filenameList = filenameList
630
592
631 return pathList, filenameList
593 return pathList, filenameList
632
594
633
595
596 def __searchFiles(self, path, startDateTime, endDateTime, set, expLabel, ext, online):
597
598 if online:
599 pathList, filenameList = self.__searchFilesOnline(path, startDateTime, endDateTime, set, expLabel, ext)
600 else:
601 pathList, filenameList = self.__searchFilesOffline(path, startDateTime, endDateTime, set, expLabel, ext)
602
603 return 1
604
634 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
605 def setup( self, path, startDateTime, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
635 """
606 """
636 Desc :
637 setup configura los parametros de lectura de la clase SpectraReader.
607 setup configura los parametros de lectura de la clase SpectraReader.
638
608
639 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
609 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
640 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
610 que coincidan con los parametros especificados; esta lista de archivos son almacenados en
641 self.filenameList.
611 self.filenameList.
642
612
643 Input:
613 Input:
644 path : Directorios donde se ubican los datos a leer. Dentro de este
614 path : Directorios donde se ubican los datos a leer. Dentro de este
645 directorio deberia de estar subdirectorios de la forma:
615 directorio deberia de estar subdirectorios de la forma:
646
616
647 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
617 path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
648
618
649 startDateTime : Fecha inicial. Rechaza todos los archivos donde
619 startDateTime : Fecha inicial. Rechaza todos los archivos donde
650 file end time < startDatetime (objeto datetime.datetime)
620 file end time < startDatetime (objeto datetime.datetime)
651
621
652 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
622 endDateTime : Fecha final. Si no es None, rechaza todos los archivos donde
653 file end time < startDatetime (objeto datetime.datetime)
623 file end time < startDatetime (objeto datetime.datetime)
654
624
655 set : Set del primer archivo a leer. Por defecto None
625 set : Set del primer archivo a leer. Por defecto None
656
626
657 expLabel : Nombre del subdirectorio de datos. Por defecto ""
627 expLabel : Nombre del subdirectorio de datos. Por defecto ""
658
628
659 ext : Extension de los archivos a leer. Por defecto .r
629 ext : Extension de los archivos a leer. Por defecto .r
660
630
661 online : Si es == a 0 entonces busca files que cumplan con las condiciones dadas
631 online :
662
632
663 Return:
633 Return:
664 0 : Si no encuentra files que cumplan con las condiciones dadas
665 1 : Si encuentra files que cumplan con las condiciones dadas
666
634
667 Affected:
635 Affected:
668 self.startUTCSeconds
636
669 self.endUTCSeconds
637 Excepciones:
670 self.startYear
638
671 self.endYear
639 Example:
672 self.startDoy
640
673 self.endDoy
674 self.__pathList
675 self.filenameList
676 self.online
677 """
641 """
678 if online == 0:
642 if online == 0:
679 pathList, filenameList = self.__searchFiles( path, startDateTime, endDateTime, set, expLabel, ext )
643 pathList, filenameList = self.__searchFilesOffline(path, startDateTime, endDateTime, set, expLabel, ext)
680
681 self.__idFile = -1
644 self.__idFile = -1
682
645
646 else:
647 filepath, filename, year, doy, set = self.__searchFilesOnline()
648 set -= 1
649
683 if not(self.__setNextFile()):
650 if not(self.__setNextFile()):
684 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
651 print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
685 return 0
652 return 0
686
653
687 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
654 self.startUTCSeconds = time.mktime(startDateTime.timetuple())
688 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
655 self.endUTCSeconds = time.mktime(endDateTime.timetuple())
689
656
690 self.startYear = startDateTime.timetuple().tm_year
657 self.startYear = startDateTime.timetuple().tm_year
691 self.endYear = endDateTime.timetuple().tm_year
658 self.endYear = endDateTime.timetuple().tm_year
692
659
693 self.startDoy = startDateTime.timetuple().tm_yday
660 self.startDoy = startDateTime.timetuple().tm_yday
694 self.endDoy = endDateTime.timetuple().tm_yday
661 self.endDoy = endDateTime.timetuple().tm_yday
695 #call fillHeaderValues() - to Data Object
662 #call fillHeaderValues() - to Data Object
696
663
697 self.__pathList = pathList
664 self.__pathList = pathList
698 self.filenameList = filenameList
665 self.filenameList = filenameList
699 self.online = online
666 self.online = online
700
667
701 return 1
668 self.__startDateTime = startDateTime
702
669
670 return 1
703
671
704 def readNextBlock(self):
672 def readNextBlock(self):
705 """
673 """
706 Desc:
674 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
707 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
708 mas bloques disponibles en el archivo actual salta al siguiente.
675 mas bloques disponibles en el archivo actual salta al siguiente.
709
676
710 Affected:
711 self.__lastUTTime
712
713 Return: None
714 """
677 """
715
678
716 if not( self.__setNewBlock() ):
679 if not( self.__setNewBlock() ):
717 return 0
680 return 0
718
681
719 self.__readBlock()
682 self.__readBlock()
720
683
721 self.__lastUTTime = self.m_BasicHeader.utc
684 self.__lastUTTime = self.m_BasicHeader.utc
722
685
723 return 1
686 return 1
724
687
725
688
726 def getData(self):
689 def getData(self):
727 """
690 """
728 Desc:
691 getData copia el buffer de lectura a la clase "Spectra",
729 Copia el buffer de lectura a la clase "Spectra",
730 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
692 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
731 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
693 lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
732
694
695 Inputs:
696 None
697
733 Return:
698 Return:
734 0 : Si no hay mas archivos disponibles
699 data : retorna un bloque de datos (nFFTs * alturas * canales) copiados desde el
735 1 : Si hizo una buena copia del buffer
700 buffer. Si no hay mas archivos a leer retorna None.
736
701
737 Variables afectadas:
702 Variables afectadas:
738 self.m_Spectra
703 self.m_Spectra
739 self.__buffer_id
704 self.__buffer_id
740 self.flagResetProcessing
705
741 self.flagIsNewBlock
706 Excepciones:
707
742 """
708 """
743
709
744 self.flagResetProcessing = 0
710 self.flagResetProcessing = 0
745 self.flagIsNewBlock = 0
711 self.flagIsNewBlock = 0
746
712
747 if self.__hasNotDataInBuffer():
713 if self.__hasNotDataInBuffer():
748 self.readNextBlock()
714 self.readNextBlock()
749
715
750 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
716 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
751 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
717 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
752 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
718 self.m_Spectra.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
753 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
719 self.m_Spectra.m_SystemHeader = self.m_SystemHeader.copy()
754 self.m_Spectra.heights = self.__heights
720 self.m_Spectra.heights = self.__heights
755 self.m_Spectra.dataType = self.__dataType
721 self.m_Spectra.dataType = self.__dataType
756
722
757 if self.noMoreFiles == 1:
723 if self.noMoreFiles == 1:
758 print 'Process finished'
724 print 'Process finished'
759 return 0
725 return 0
760
726
761 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
727 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
728 #print type(self.__buffer_sspc)
762
729
763 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
730 time = self.m_BasicHeader.utc + self.__buffer_id*self.__ippSeconds
764
731
765 self.m_Spectra.m_BasicHeader.utc = time
732 self.m_Spectra.m_BasicHeader.utc = time
766 self.m_Spectra.data_spc = self.__buffer_spc
733 self.m_Spectra.data_spc = self.__buffer_spc
767 self.m_Spectra.data_cspc = self.__buffer_cspc
734 self.m_Spectra.data_cspc = self.__buffer_cspc
768 self.m_Spectra.data_dc = self.__buffer_dc
735 self.m_Spectra.data_dc = self.__buffer_dc
769
736
770 #call setData - to Data Object
737 #call setData - to Data Object
738
771 return 1
739 return 1
772
740
773
741
774 class SpectraWriter( DataWriter ):
742 class SpectraWriter(DataWriter):
775 """
776 Desc:
777 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
778 de los datos siempre se realiza por bloques.
779 """
780
743
781 def __init__(self):
744 def __init__(self):
782 """
783 Desc :
784 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
785
786 Affected :
787 self.m_Spectra
788 self.m_BasicHeader
789 self.m_SystemHeader
790 self.m_RadarControllerHeader
791 self.m_ProcessingHeader
792
793 Return : None
794 """
795 if m_Spectra == None:
745 if m_Spectra == None:
796 m_Spectra = Spectra()
746 m_Spectra = Spectra()
797
747
798 self.m_Spectra = m_Spectra
748 self.m_Spectra = m_Spectra
799
749
800 self.__fp = None
750 self.__fp = None
801
751
802 self.__blocksCounter = 0
752 self.__blocksCounter = 0
803
753
804 self.__setFile = None
754 self.__setFile = None
805
755
806 self.__flagIsNewFile = 0
756 self.__flagIsNewFile = 0
807
757
808 self.__buffer_spc = 0
758 self.__buffer_sspc = 0
809
759
810 self.__buffer_id = 0
760 self.__buffer_id = 0
811
761
812 self.__dataType = None
762 self.__dataType = None
813
763
814 self.__ext = None
764 self.__ext = None
815
765
816 self.nWriteBlocks = 0
766 self.nWriteBlocks = 0
817
767
818 self.flagIsNewBlock = 0
768 self.flagIsNewBlock = 0
819
769
820 self.noMoreFiles = 0
770 self.noMoreFiles = 0
821
771
822 self.filename = None
772 self.filename = None
823
773
824 self.m_BasicHeader= BasicHeader()
774 self.m_BasicHeader= BasicHeader()
825
775
826 self.m_SystemHeader = SystemHeader()
776 self.m_SystemHeader = SystemHeader()
827
777
828 self.m_RadarControllerHeader = RadarControllerHeader()
778 self.m_RadarControllerHeader = RadarControllerHeader()
829
779
830 self.m_ProcessingHeader = ProcessingHeader()
780 self.m_ProcessingHeader = ProcessingHeader()
831
781
832
833 def __setNextFile(self):
782 def __setNextFile(self):
834 """
835 Desc:
836 Determina el siguiente file que sera escrito
837
838 Affected:
839 self.filename
840 self.__subfolder
841 self.__fp
842 self.__setFile
843 self.__flagIsNewFile
844
845 Return:
846 0 : Si el archivo no puede ser escrito
847 1 : Si el archivo esta listo para ser escrito
848 """
849 setFile = self.__setFile
783 setFile = self.__setFile
850 ext = self.__ext
784 ext = self.__ext
851 path = self.__path
785 path = self.__path
852
786
853 setFile += 1
787 setFile += 1
854
788
855 if not( self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile ):
789 if not(self.__blocksCounter >= self.m_ProcessingHeader.dataBlocksPerFile):
856 self.__fp.close()
790 self.__fp.close()
857 return 0
791 return 0
858
792
859 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
793 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
860 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
794 file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_doy,setFile,ext)
861 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
795 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_doy)
862 tmp = os.path.join(path,subfolder)
796 tmp = os.path.join(path,subfolder)
863 if not(os.path.exists(tmp)):
797 if not(os.path.exists(tmp)):
864 os.mkdir(tmp)
798 os.mkdir(tmp)
865
799
866 filename = os.path.join(path,subfolder,file)
800 filename = os.path.join(path,subfolder,file)
867 fp = open(filename,'wb')
801 fp = open(filename,'wb')
868
802
869 #guardando atributos
803 #guardando atributos
870 self.filename = filename
804 self.filename = filename
871 self.__subfolder = subfolder
805 self.__subfolder = subfolder
872 self.__fp = fp
806 self.__fp = fp
873 self.__setFile = setFile
807 self.__setFile = setFile
874 self.__flagIsNewFile = 1
808 self.__flagIsNewFile = 1
875
809
876 print 'Writing the file: %s'%self.filename
810 print 'Writing the file: %s'%self.filename
877
811
878 return 1
812 return 1
879
813
880
814
881 def __setNewBlock( self ):
882 """
883 Desc:
884 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
885
815
886 Return:
816 def __setNewBlock(self):
887 0 : si no pudo escribir nada
888 1 : Si escribio el Basic el First Header
889 """
890 if self.__fp == None:
817 if self.__fp == None:
891 return 0
818 return 0
892
819
893 if self.__flagIsNewFile:
820 if self.__flagIsNewFile:
894 return 1
821 return 1
895
822
896 #Bloques completados?
823 #Bloques completados?
897 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
824 if self.__blocksCounter < self.m_ProcessingHeader.profilesPerBlock:
898 self.__writeBasicHeader()
825 self.__writeBasicHeader()
899 return 1
826 return 1
900
827
901 if not(self.__setNextFile()):
828 if not(self.__setNextFile()):
902 return 0
829 return 0
903
830
904 self.__writeFirstHeader()
831 self.__writeFirstHeader()
905
832
906 return 1
833 return 1
907
834
908
909 def __writeBlock(self):
835 def __writeBlock(self):
910 """
911 Desc:
912 Escribe el buffer en el file designado
913
836
914 Return: None
837 numpy.save(self.__fp,self.__buffer_sspc)
915
838
916 Affected:
839 self.__buffer_sspc = numpy.array([],self.__dataType)
917 self.__buffer_spc
918 self.__buffer_id
919 self.__flagIsNewFile
920 self.flagIsNewBlock
921 self.nWriteBlocks
922 self.__blocksCounter
923
924 Return: None
925 """
926 numpy.save(self.__fp,self.__buffer_spc)
927
928 self.__buffer_spc = numpy.array([],self.__dataType)
929
840
930 self.__buffer_id = 0
841 self.__buffer_id = 0
931
842
932 self.__flagIsNewFile = 0
843 self.__flagIsNewFile = 0
933
844
934 self.flagIsNewBlock = 1
845 self.flagIsNewBlock = 1
935
846
936 self.nWriteBlocks += 1
847 self.nWriteBlocks += 1
937
848
938 self.__blocksCounter += 1
849 self.__blocksCounter += 1
939
850
940
941 def writeNextBlock(self):
851 def writeNextBlock(self):
942 """
943 Desc:
944 Selecciona el bloque siguiente de datos y los escribe en un file
945
946 Return:
947 0 : Si no hizo pudo escribir el bloque de datos
948 1 : Si no pudo escribir el bloque de datos
949 """
950 if not(self.__setNewBlock()):
852 if not(self.__setNewBlock()):
951 return 0
853 return 0
952
854
953 self.__writeBlock()
855 self.__writeBlock()
954
856
955 return 1
857 return 1
956
858
957
958 def __hasAllDataInBuffer( self ):
859 def __hasAllDataInBuffer(self):
959 """
960 Desc:
961 Determina si se tiene toda la data en el buffer
962
963 Return:
964 0 : Si no tiene toda la data
965 1 : Si tiene toda la data
966 """
967 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
860 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
968 return 1
861 return 1
969
862
970 return 0
863 return 0
971
864
972
973 def putData( self ):
865 def putData(self):
974 """
975 Desc:
976 Setea un bloque de datos y luego los escribe en un file
977
978 Return:
979 None : Si no hay data o no hay mas files que puedan escribirse
980 1 : Si se escribio la data de un bloque en un file
981
982 Affected:
983 self.__buffer_spc
984 self.__buffer_id
985 """
986 self.flagIsNewBlock = 0
866 self.flagIsNewBlock = 0
987
867
988 if self.m_Spectra.noData:
868 if self.m_Spectra.noData:
989 return None
869 return None
990
870
991 shape = self.m_Spectra.data.shape
871 shape = self.m_Spectra.data.shape
992 data = numpy.zeros(shape,self.__dataType)
872 data = numpy.zeros(shape,self.__dataType)
993 data['real'] = self.m_Spectra.data.real
873 data['real'] = self.m_Spectra.data.real
994 data['imag'] = self.m_Spectra.data.imag
874 data['imag'] = self.m_Spectra.data.imag
995 data = data.reshape((-1))
875 data = data.reshape((-1))
996
876
997 self.__buffer_spc = numpy.hstack((self.__buffer_spc,data))
877 self.__buffer_sspc = numpy.hstack((self.__buffer_sspc,data))
998
878
999 self.__buffer_id += 1
879 self.__buffer_id += 1
1000
880
1001 if __hasAllDataInBuffer():
881 if __hasAllDataInBuffer():
1002 self.writeNextBlock()
882 self.writeNextBlock()
1003
883
884
1004 if self.noMoreFiles:
885 if self.noMoreFiles:
1005 print 'Process finished'
886 print 'Process finished'
1006 return None
887 return None
1007
888
1008 return 1
889 return 1
1009
890
1010
891
1011 def setup( self, set=None, format=None ):
892 def setup(self,path,set=None,format=None):
1012 """
1013 Desc:
1014 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1015
893
1016 Inputs:
1017 set : el seteo del file a salvar
1018 format : formato en el cual sera salvado un file
1019 """
1020 if set == None:
894 if set == None:
1021 set = -1
895 set = -1
1022 else:
896 else:
1023 set -= 1
897 set -= 1
1024
898
1025 if format == 'hdf5':
899 if format == 'hdf5':
1026 ext = '.hdf5'
900 ext = '.hdf5'
1027 print 'call hdf5 library'
901 print 'call hdf5 library'
1028 return 0
902 return 0
1029
903
1030 if format == 'rawdata':
904 if format == 'rawdata':
1031 ext = '.r'
905 ext = '.r'
1032
906
1033 #call to config_headers
907 #call to config_headers
1034
908
1035 self.__setFile = set
909 self.__setFile = set
1036
910
1037 if not( self.__setNextFile() ):
911 if not(self.__setNextFile()):
1038 print "zzzzzzzzzzzz"
912 print "zzzzzzzzzzzz"
1039 return 0
913 return 0
1040
914
1041 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
915 self.__writeFirstHeader() # dentro de esta funcion se debe setear e __dataType
1042
916
1043 self.__buffer_spc = numpy.array( [],self.__dataType )
917 self.__buffer_sspc = numpy.array([],self.__dataType)
918
1044
919
1045
920
1046 def __writeBasicHeader(self):
921 def __writeBasicHeader(self):
1047 pass
922 pass
1048
923
1049
1050 def __writeFirstHeader(self):
924 def __writeFirstHeader(self):
1051 pass
925 pass
General Comments 0
You need to be logged in to leave comments. Login now