##// END OF EJS Templates
schain
RSS
SpectraIO.py: Salto de archivos online ha sido agregado
Miguel Valdez -
r29:ff31b7b057ae
parent child
Show More
Show file before | Show file after | Hide comments
@@ -21,10 +21,8 from DataIO import DataWriter
21 21
22 22 from Model.Spectra import Spectra
23 23
24
25 24 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
26 25 """
27 Desc :
28 26 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
29 27 o no dentro del rango de fecha especificado.
30 28
@@ -33,7 +31,6 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
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 36
@@ -44,11 +41,12 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
44 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
@@ -65,10 +63,9 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
65 63
66 64 class SpectraReader( DataReader ):
67 65 """
68 Desc :
69 66 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
70 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
71 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
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".
72 69
73 70 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
74 71 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
@@ -76,6 +73,7 class SpectraReader( DataReader ):
76 73 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
77 74
78 75 Example :
76
79 77 dpath = "/home/myuser/data"
80 78
81 79 startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
@@ -100,13 +98,11 class SpectraReader( DataReader ):
100 98 #speed of light
101 99 __c = 3E8
102 100
103
104 101 def __init__( self, m_Spectra = None ):
105 102 """
106 Desc :
107 103 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
108 104
109 Inputs :
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,
@@ -114,14 +110,17 class SpectraReader( DataReader ):
114 110 bloque de datos.
115 111 Si este parametro no es pasado se creara uno internamente.
116 112
117 Affected :
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 119
124 Return : Nada
120
121 Return:
122 Void
123
125 124 """
126 125 if m_Spectra == None:
127 126 m_Spectra = Spectra()
@@ -183,12 +182,6 class SpectraReader( DataReader ):
183 182 self.__buffer_cspc = None
184 183 self.__buffer_dc = None
185 184
186 self.Npair_SelfSpectra = 0
187 self.Npair_CrossSpectra = 0
188
189 self.pts2read_SelfSpectra = 0
190 self.pts2read_CrossSpectra = 0
191
192 185 self.__buffer_id = 0
193 186
194 187 self.__ippSeconds = 0
@@ -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 207
221
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 213
240
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 225
278
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 )
268 return:
269 bool
350 270
271 """
272 nFiles = 3
273 nTries = 3
351 274
352 def __setNextFileOnline( self ):
353 return 1
275 countFiles = 0
276 countTries = 0
354 277
278 fileStatus = False
355 279
356 def __setNextFileOffline( self ):
357 """
358 Desc :
359 Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
280 while(True):
281 countFiles += 1
360 282
361 Affected :
362 self.__flagIsNewFile
363 self.__idFile
364 self.filename
365 self.fileSize
366 self.__fp
283 if countFiles > nFiles+1:
284 break
367 285
368 Return :
369 0 : si un determinado file no puede ser abierto
370 1 : si el file fue abierto con exito
286 self.set += 1
371 287
372 Excepciones :
373 Si un determinado file no puede ser abierto
374 """
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 363 def __setNextFile( self ):
413 """
414 Desc :
415 Determina el siguiente file a leer y si hay uno disponible lee el First Header
416 364
417 Affected :
418 self.m_BasicHeader
419 self.m_SystemHeader
420 self.m_RadarControllerHeader
421 self.m_ProcessingHeader
422 self.firstHeaderSize
365 if self.__fp != None:
366 self.__fp.close()
423 367
424 Return :
425 0 : Si no hay files disponibles
426 1 : Si hay mas files disponibles
427 """
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 413 __readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
487 414 (self.__fp) y actualiza todos los parametros relacionados al bloque de datos
488 415 (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
489 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
510 453
511 spc = spc.reshape( (self.Npair_SelfSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
454 spc = numpy.fromfile(self.__fp, self.__dataType[0], int(pts2read*Npair_SelfSpectra))
455 cspc = numpy.fromfile(self.__fp, self.__dataType, int(pts2read*Npair_CrossSpectra))
456 dc = numpy.fromfile(self.__fp, self.__dataType, int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
512 457
513 cspc = cspc.reshape( (self.Npair_CrossSpectra, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
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 462 if not( self.m_ProcessingHeader.shif_fft ):
517 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
518 cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
463 spc = numpy.roll(spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
464 cspc = numpy.roll(cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2)
519 465
520 466 spc = numpy.transpose( spc, (0,2,1) )
521 467 cspc = numpy.transpose( cspc, (0,2,1) )
522 468 #dc = numpy.transpose(dc, (0,2,1))
523 469
524 """
525 470 data_spc = spc
526 471 data_cspc = cspc['real'] + cspc['imag']*1j
527 472 data_dc = dc['real'] + dc['imag']*1j
@@ -529,10 +474,6 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
@@ -544,10 +485,28 class SpectraReader( DataReader ):
544 485 def __hasNotDataInBuffer( self ):
545 486 return 1
546 487
488 def __searchFilesOnline(self, path, startDateTime, expLabel = "", ext = ".pdata"):
489 """
490
491
492 Return:
493
494 filepath
495
496 filename
497
498 year
499
500 doy
501
502 set
547 503
548 def __searchFiles( self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata" ):
549 504 """
550 Desc :
505
506 pass
507
508 def __searchFilesOffline(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".pdata"):
509 """
551 510 __searchFiles realiza una busqueda de los archivos que coincidan con los parametros
552 511 especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
553 512 correcta la estructura de directorios debe ser la siguiente:
@@ -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,9 +593,17 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 607 setup configura los parametros de lectura de la clase SpectraReader.
638 608
639 609 Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
@@ -658,28 +628,25 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
636
637 Excepciones:
638
639 Example:
640
677 641 """
678 642 if online == 0:
679 pathList, filenameList = self.__searchFiles( path, startDateTime, endDateTime, set, expLabel, ext )
680
643 pathList, filenameList = self.__searchFilesOffline(path, startDateTime, endDateTime, set, expLabel, ext)
681 644 self.__idFile = -1
682 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 652 return 0
@@ -698,19 +665,15 class SpectraReader( DataReader ):
698 665 self.filenameList = filenameList
699 666 self.online = online
700 667
701 return 1
668 self.__startDateTime = startDateTime
702 669
670 return 1
703 671
704 672 def readNextBlock(self):
705 673 """
706 Desc:
707 Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
674 readNextBlock establece un nuevo bloque de datos a leer y los lee, si es que no existiese
708 675 mas bloques disponibles en el archivo actual salta al siguiente.
709 676
710 Affected:
711 self.__lastUTTime
712
713 Return: None
714 677 """
715 678
716 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",
691 getData copia el buffer de lectura a la clase "Spectra",
730 692 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
731 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 742 class SpectraWriter( DataWriter ):
775 """
776 Desc:
777 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
778 de los datos siempre se realiza por bloques.
779 """
780 743
781 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
@@ -829,23 +779,7 class SpectraWriter( DataWriter ):
829 779
830 780 self.m_ProcessingHeader = ProcessingHeader()
831 781
832
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
@@ -878,15 +812,8 class SpectraWriter( DataWriter ):
878 812 return 1
879 813
880 814
881 def __setNewBlock( self ):
882 """
883 Desc:
884 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
885 815
886 Return:
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
@@ -905,27 +832,11 class SpectraWriter( DataWriter ):
905 832
906 833 return 1
907 834
908
909 835 def __writeBlock(self):
910 """
911 Desc:
912 Escribe el buffer en el file designado
913 836
914 Return: None
837 numpy.save(self.__fp,self.__buffer_sspc)
915 838
916 Affected:
917 self.__buffer_spc
918 self.__buffer_id
919 self.__flagIsNewFile
920 self.flagIsNewBlock
921 self.nWriteBlocks
922 self.__blocksCounter
923
924 Return: None
925 """
926 numpy.save(self.__fp,self.__buffer_spc)
927
928 self.__buffer_spc = numpy.array([],self.__dataType)
839 self.__buffer_sspc = numpy.array([],self.__dataType)
929 840
930 841 self.__buffer_id = 0
931 842
@@ -937,16 +848,7 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
@@ -954,35 +856,13 class SpectraWriter( DataWriter ):
954 856
955 857 return 1
956 858
957
958 859 def __hasAllDataInBuffer( self ):
959 """
960 Desc:
961 Determina si se tiene toda la data en el buffer
962
963 Return:
964 0 : Si no tiene toda la data
965 1 : Si tiene toda la data
966 """
967 860 if self.__buffer_id >= self.m_ProcessingHeader.profilesPerBlock:
968 861 return 1
969 862
970 863 return 0
971 864
972
973 865 def putData( self ):
974 """
975 Desc:
976 Setea un bloque de datos y luego los escribe en un file
977
978 Return:
979 None : Si no hay data o no hay mas files que puedan escribirse
980 1 : Si se escribio la data de un bloque en un file
981
982 Affected:
983 self.__buffer_spc
984 self.__buffer_id
985 """
986 866 self.flagIsNewBlock = 0
987 867
988 868 if self.m_Spectra.noData:
@@ -994,13 +874,14 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 882 self.writeNextBlock()
1003 883
884
1004 885 if self.noMoreFiles:
1005 886 print 'Process finished'
1006 887 return None
@@ -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
892 def setup(self,path,set=None,format=None):
1015 893
1016 Inputs:
1017 set : el seteo del file a salvar
1018 format : formato en el cual sera salvado un file
1019 """
1020 894 if set == None:
1021 895 set = -1
1022 896 else:
@@ -1040,12 +914,12 class SpectraWriter( DataWriter ):
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)
918
1044 919
1045 920
1046 921 def __writeBasicHeader(self):
1047 922 pass
1048 923
1049
1050 924 def __writeFirstHeader(self):
1051 925 pass
General Comments 0
You need to be logged in to leave comments. Login now