##// 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
@@ -21,34 +21,32 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
@@ -63,19 +61,19 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
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)
@@ -100,28 +98,29 class SpectraReader( DataReader ):
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()
@@ -181,13 +180,7 class SpectraReader( DataReader ):
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
@@ -199,105 +192,38 class SpectraReader( DataReader ):
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()
@@ -335,43 +261,68 class SpectraReader( DataReader ):
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):
@@ -394,6 +345,7 class SpectraReader( DataReader ):
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
@@ -408,23 +360,11 class SpectraReader( DataReader ):
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:
@@ -437,20 +377,7 class SpectraReader( DataReader ):
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
@@ -480,48 +407,66 class SpectraReader( DataReader ):
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
@@ -529,11 +474,7 class SpectraReader( DataReader ):
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
@@ -541,22 +482,40 class SpectraReader( DataReader ):
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
@@ -589,6 +548,9 class SpectraReader( DataReader ):
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 ..."
@@ -631,14 +593,22 class SpectraReader( DataReader ):
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
@@ -658,31 +628,28 class SpectraReader( DataReader ):
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())
@@ -698,19 +665,15 class SpectraReader( DataReader ):
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() ):
@@ -725,20 +688,23 class SpectraReader( DataReader ):
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
@@ -759,6 +725,7 class SpectraReader( DataReader ):
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
@@ -768,30 +735,13 class SpectraReader( DataReader ):
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
@@ -805,7 +755,7 class SpectraWriter( DataWriter ):
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
@@ -828,31 +778,15 class SpectraWriter( DataWriter ):
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
@@ -877,16 +811,9 class SpectraWriter( DataWriter ):
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
@@ -904,28 +831,12 class SpectraWriter( DataWriter ):
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
@@ -937,52 +848,21 class SpectraWriter( DataWriter ):
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:
@@ -994,12 +874,13 class SpectraWriter( DataWriter ):
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'
@@ -1008,15 +889,8 class SpectraWriter( DataWriter ):
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:
@@ -1034,18 +908,18 class SpectraWriter( DataWriter ):
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