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