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