##// END OF EJS Templates
schain-jc
RSS
SPECTRAIO.py:...
Victor Sarmiento -
r47:580af48a6d5c
parent child
Show More
Show file before | Show file after | Hide comments
@@ -22,7 +22,40 from DataIO import DataWriter
22 from Model.Spectra import Spectra
22 from Model.Spectra import Spectra
23
23
24
24
25 def getlastFileFromPath( pathList, ext ):
25 def isFileOK(filename):
26 """
27 Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
28 si no seria un archivo invalido
29
30 Return:
31 True : si es un archivo valido
32 False : si no es un archivo valido
33
34 Exceptions:
35 Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
36 una exception
37 """
38 m_BasicHeader = BasicHeader()
39 m_ProcessingHeader = ProcessingHeader()
40 m_RadarControllerHeader = RadarControllerHeader()
41 m_SystemHeader = SystemHeader()
42 fp = None
43
44 try:
45 fp = open( filename,'rb' ) #lectura binaria
46 m_BasicHeader.read(fp)
47 m_SystemHeader.read(fp)
48 m_RadarControllerHeader.read(fp)
49 m_ProcessingHeader.read(fp)
50 fp.close()
51 except:
52 if fp != None: fp.close()
53 return False
54
55 return True
56
57
58 def getlastFileFromPath(pathList,ext):
26 """
59 """
27 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
60 Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
28 al final de la depuracion devuelve el ultimo file de la lista que quedo.
61 al final de la depuracion devuelve el ultimo file de la lista que quedo.
@@ -59,7 +92,7 def getlastFileFromPath( pathList, ext ):
59 return filename
92 return filename
60
93
61
94
62 def checkForRealPath( path, year, doy, set, ext ):
95 def checkForRealPath(path,year,doy,set,ext):
63 """
96 """
64 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
97 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
65 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
98 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
@@ -100,7 +133,7 def checkForRealPath( path, year, doy, set, ext ):
100
133
101 return filepath, filename
134 return filepath, filename
102
135
103 def isNumber( str ):
136 def isNumber(str):
104 """
137 """
105 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
138 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
106
139
@@ -121,7 +154,7 def isNumber( str ):
121
154
122
155
123
156
124 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
157 def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
125 """
158 """
126 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
159 Esta funcion determina si un archivo de datos en formato Jicamarca(.r) se encuentra
127 o no dentro del rango de fecha especificado.
160 o no dentro del rango de fecha especificado.
@@ -157,11 +190,11 def isThisFileinRange( filename, startUTSeconds, endUTSeconds ):
157
190
158 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
191 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds >= m_BasicHeader.utc)):
159 return 0
192 return 0
160
193
161 return 1
194 return 1
162
195
163
196
164 class SpectraReader( DataReader ):
197 class SpectraReader(DataReader):
165 """
198 """
166 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
199 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
167 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
200 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
@@ -198,7 +231,7 class SpectraReader( DataReader ):
198 __c = 3E8
231 __c = 3E8
199
232
200
233
201 def __init__( self, m_Spectra = None ):
234 def __init__(self,m_Spectra=None):
202 """
235 """
203 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
236 Inicializador de la clase SpectraReader para la lectura de datos de espectros.
204
237
@@ -297,7 +330,7 class SpectraReader( DataReader ):
297
330
298 self.datablock_id = 9999
331 self.datablock_id = 9999
299
332
300 self.__delay = 7 #seconds
333 self.__delay = 2 #seconds
301 self.__nTries = 3 #quantity tries
334 self.__nTries = 3 #quantity tries
302 self.__nFiles = 3 #number of files for searching
335 self.__nFiles = 3 #number of files for searching
303 self.__year = 0
336 self.__year = 0
@@ -305,9 +338,9 class SpectraReader( DataReader ):
305 self.__set = 0
338 self.__set = 0
306 self.__ext = None
339 self.__ext = None
307 self.__path = None
340 self.__path = None
308
341 self.nBlocks = 0
309
342
310 def __rdSystemHeader( self, fp=None ):
343 def __rdSystemHeader(self,fp=None):
311 """
344 """
312 Lectura del System Header
345 Lectura del System Header
313
346
@@ -326,7 +359,7 class SpectraReader( DataReader ):
326
359
327
360
328
361
329 def __rdRadarControllerHeader( self, fp=None ):
362 def __rdRadarControllerHeader(self,fp=None):
330 """
363 """
331 Lectura del Radar Controller Header
364 Lectura del Radar Controller Header
332
365
@@ -344,7 +377,7 class SpectraReader( DataReader ):
344 self.m_RadarControllerHeader.read(fp)
377 self.m_RadarControllerHeader.read(fp)
345
378
346
379
347 def __rdProcessingHeader( self,fp=None ):
380 def __rdProcessingHeader(self,fp=None):
348 """
381 """
349 Lectura del Processing Header
382 Lectura del Processing Header
350
383
@@ -362,7 +395,7 class SpectraReader( DataReader ):
362 self.m_ProcessingHeader.read(fp)
395 self.m_ProcessingHeader.read(fp)
363
396
364
397
365 def __rdBasicHeader( self, fp=None ):
398 def __rdBasicHeader(self,fp=None):
366 """
399 """
367 Lectura del Basic Header
400 Lectura del Basic Header
368
401
@@ -380,7 +413,7 class SpectraReader( DataReader ):
380 self.m_BasicHeader.read(fp)
413 self.m_BasicHeader.read(fp)
381
414
382
415
383 def __readFirstHeader( self ):
416 def __readFirstHeader(self):
384 """
417 """
385 Lectura del First Header, es decir el Basic Header y el Long Header
418 Lectura del First Header, es decir el Basic Header y el Long Header
386
419
@@ -455,13 +488,11 class SpectraReader( DataReader ):
455
488
456 self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels
489 self.__blocksize = self.__pts2read_SelfSpectra + self.__pts2read_CrossSpectra + self.__pts2read_DCchannels
457
490
458 print "SIZEEEE ",self.__blocksize, self.m_ProcessingHeader.blockSize
459
460 self.m_Spectra.nChannels = self.nChannels
491 self.m_Spectra.nChannels = self.nChannels
461 self.m_Spectra.nPairs = self.nPairs
492 self.m_Spectra.nPairs = self.nPairs
462
493
463
494
464 def __setNextFileOnline( self ):
495 def __setNextFileOnline(self):
465 """
496 """
466 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
497 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
467 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
498 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
@@ -485,9 +516,10 class SpectraReader( DataReader ):
485 countFiles = 0
516 countFiles = 0
486 countTries = 0
517 countTries = 0
487
518
488 fileStatus = 0
519 #fileStatus = 0
489 notFirstTime_flag = False
520 notFirstTime_flag = False
490 bChangeDir = False
521 fileOk_flag = False
522 changeDir_flag = False
491
523
492 fileSize = 0
524 fileSize = 0
493 fp = None
525 fp = None
@@ -507,12 +539,35 class SpectraReader( DataReader ):
507 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
539 if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
508 self.__set = 0
540 self.__set = 0
509 self.__doy += 1
541 self.__doy += 1
510 bChangeDir = True
542 changeDir_flag = True
511
543
512 file = None
544 file = None
513 filename = None
545 filename = None
514
546 fileOk_flag = False
515 countTries = 0
547
548 #busca el 1er file disponible
549 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
550
551 if file == None:
552 if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
553 print "\tsearching next \"%s\" file ..." % ( filename )
554 continue
555 else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no
556 for nTries in range( self.__nTries ):
557 print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 )
558 time.sleep( self.__delay )
559
560 file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
561 if file != None:
562 fileOk_flag = True
563 break
564
565 if not( fileOk_flag ): #no encontro ningun file valido a leer
566 notFirstTime_flag = True
567 continue
568
569
570 """countTries = 0
516
571
517 #espero hasta encontrar el 1er file disponible
572 #espero hasta encontrar el 1er file disponible
518 while( True ):
573 while( True ):
@@ -536,51 +591,47 class SpectraReader( DataReader ):
536 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
591 if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
537 notFirstTime_flag = True
592 notFirstTime_flag = True
538 continue #vuelvo al inico del while principal
593 continue #vuelvo al inico del while principal
594 """
595
596 #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
597 currentSize = os.path.getsize( file )
598 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
599
600 #si el tamanho es suficiente entonces deja de buscar
601 if currentSize > neededSize:
602 fileOk_flag = True
603 break
539
604
540 countTries = 0
605 fileOk_flag = False
606 #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo
607 #por una cierta cantidad de veces hasta que el contenido del file sea valido
608 if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
609 print "\tsearching next \"%s\" file ..." % filename
610 changeDir_flag = False
611 continue
541
612
542 #una vez que se obtuvo el 1er file valido se procede a checkear su contenido, y se espera una cierta cantidad
613 for nTries in range( self.__nTries ):
543 #de tiempo por una cierta cantidad de veces hasta que el contenido del file sea un contenido valido
614 print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
544 while( True ):
615 time.sleep( self.__delay )
545 countTries += 1
616
546 if countTries > self.__nTries:
617 currentSize = os.path.getsize( file )
547 break
548
549 try:
550 fp = open(file)
551 except:
552 print "The file \"%s\" can't be opened" % file
553 break
554
555 fileSize = os.path.getsize( file )
556 currentSize = fileSize - fp.tell()
557 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
618 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
558
619
559 if currentSize > neededSize:
620 if currentSize > neededSize:
560 fileStatus = 1
621 fileOk_flag = True
561 break
622 break
562
623
563 fp.close()
624 if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
564
565 if bChangeDir: #si al buscar un file cambie de directorio ya no espero y salgo del bucle while
566 print "\tsearching next \"%s\" file ..." % filename
567 break
568
569 print "\twaiting for block of \"%s\" file ..." % filename
570 time.sleep( self.__delay )
571
572 if fileStatus == 1:
573 break
625 break
574
626
575 print "Skipping the file \"%s\" due to this files is empty" % filename
627 print "Skipping the file \"%s\" due to this files is empty" % filename
576 countFiles = 0
628 countFiles = 0
577
629
578
630 if fileOk_flag:
579 if fileStatus == 1:
631 self.fileSize = os.path.getsize( file ) #fileSize
580 self.fileSize = fileSize
581 self.filename = file#name
632 self.filename = file#name
582 self.__flagIsNewFile = 1
633 self.__flagIsNewFile = 1
583 self.__fp = fp
634 self.__fp = open(file)
584 self.noMoreFiles = 0
635 self.noMoreFiles = 0
585 print 'Setting the file: %s' % file #name
636 print 'Setting the file: %s' % file #name
586 else:
637 else:
@@ -590,7 +641,7 class SpectraReader( DataReader ):
590 self.noMoreFiles = 1
641 self.noMoreFiles = 1
591 print 'No more Files'
642 print 'No more Files'
592
643
593 return fileStatus
644 return fileOk_flag
594
645
595
646
596 def __setNextFileOffline( self ):
647 def __setNextFileOffline( self ):
@@ -619,6 +670,7 class SpectraReader( DataReader ):
619
670
620 if not( idFile < len(self.filenameList) ):
671 if not( idFile < len(self.filenameList) ):
621 self.noMoreFiles = 1
672 self.noMoreFiles = 1
673 print 'No more Files'
622 return 0
674 return 0
623
675
624 filename = self.filenameList[idFile]
676 filename = self.filenameList[idFile]
@@ -638,6 +690,7 class SpectraReader( DataReader ):
638 continue
690 continue
639
691
640 break
692 break
693
641 self.__flagIsNewFile = 1
694 self.__flagIsNewFile = 1
642 self.__idFile = idFile
695 self.__idFile = idFile
643 self.filename = filename
696 self.filename = filename
@@ -672,15 +725,18 class SpectraReader( DataReader ):
672 else:
725 else:
673 newFile = self.__setNextFileOffline()
726 newFile = self.__setNextFileOffline()
674
727
728 if self.noMoreFiles:
729 sys.exit(0)
730
675 if not(newFile):
731 if not(newFile):
676 return 0
732 return 0
677
733
678 self.__readFirstHeader()
734 self.__readFirstHeader()
679
735 self.nBlocks = 0
680 return 1
736 return 1
681
737
682
738
683 def __setNewBlock( self ):
739 def __setNewBlock(self):
684 """
740 """
685 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
741 Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
686
742
@@ -706,21 +762,28 class SpectraReader( DataReader ):
706 if ( currentSize >= neededSize ):
762 if ( currentSize >= neededSize ):
707 self.__rdBasicHeader()
763 self.__rdBasicHeader()
708 return 1
764 return 1
709 elif self.online:
765
710 nTries = 0
766 #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
711 while( nTries < self.__nTries ):
767 elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
712 nTries += 1
768 for nTries in range( self.__nTries ):
713 print "Waiting for the next block, try %03d ..." % nTries
769
770 fpointer = self.__fp.tell()
771 self.__fp.close()
772
773 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
714 time.sleep( self.__delay )
774 time.sleep( self.__delay )
715
775
716 fileSize = os.path.getsize(self.filename)
776 self.__fp = open( self.filename, 'rb' )
717 currentSize = fileSize - self.__fp.tell()
777 self.__fp.seek( fpointer )
778
779 self.fileSize = os.path.getsize( self.filename )
780 currentSize = self.fileSize - self.__fp.tell()
718 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
781 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
719
782
720 if ( currentSize >= neededSize ):
783 if ( currentSize >= neededSize ):
721 self.__rdBasicHeader()
784 self.__rdBasicHeader()
722 return 1
785 return 1
723
786
724 #Setting new file
787 #Setting new file
725 if not( self.__setNextFile() ):
788 if not( self.__setNextFile() ):
726 return 0
789 return 0
@@ -731,7 +794,7 class SpectraReader( DataReader ):
731
794
732 if deltaTime > self.__maxTimeStep:
795 if deltaTime > self.__maxTimeStep:
733 self.flagResetProcessing = 1
796 self.flagResetProcessing = 1
734 self.nReadBlocks = 0
797 #self.nReadBlocks = 0
735
798
736 return 1
799 return 1
737
800
@@ -753,11 +816,15 class SpectraReader( DataReader ):
753 self.__data_spc
816 self.__data_spc
754 self.__data_cspc
817 self.__data_cspc
755 self.__data_dc
818 self.__data_dc
819
820 Exceptions:
821 Si un bloque leido no es un bloque valido
756 """
822 """
757 self.datablock_id = 0
823 #self.datablock_id = 0
758 self.__flagIsNewFile = 0
824 #self.__flagIsNewFile = 0
759 self.flagIsNewBlock = 1
825 #self.flagIsNewBlock = 1
760
826
827 blockOk_flag = False
761 fpointer = self.__fp.tell()
828 fpointer = self.__fp.tell()
762
829
763 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
830 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
@@ -766,26 +833,36 class SpectraReader( DataReader ):
766
833
767 if self.online:
834 if self.online:
768 if (spc.size + cspc.size + dc.size) != self.__blocksize:
835 if (spc.size + cspc.size + dc.size) != self.__blocksize:
769 nTries = 0
836 for nTries in range( self.__nTries ):
770 while( nTries < self.__nTries ):
837 #nTries = 0
771 nTries += 1
838 #while( nTries < self.__nTries ):
772 print "Waiting for the next block, try %03d ..." % nTries
839 #nTries += 1
840 print "\tWaiting for the next block, try %03d ..." % (nTries+1)
773 time.sleep( self.__delay )
841 time.sleep( self.__delay )
774 self.__fp.seek( fpointer )
842 self.__fp.seek( fpointer )
775 fpointer = self.__fp.tell()
843 fpointer = self.__fp.tell()
776 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
844 spc = numpy.fromfile( self.__fp, self.__dataType[0], self.__pts2read_SelfSpectra )
777 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
845 cspc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_CrossSpectra )
778 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
846 dc = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
847
779 if (spc.size + cspc.size + dc.size) == self.__blocksize:
848 if (spc.size + cspc.size + dc.size) == self.__blocksize:
780 nTries = 0
849 blockOk_flag = True
781 break
850 break
782 if nTries > 0:
851 #if (spc.size + cspc.size + dc.size) == self.__blocksize:
783 return
852 # nTries = 0
784
853 # break
785 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
854 if not( blockOk_flag ):
786
855 return 0
787 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
856 #if nTries > 0:
788 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
857 # return 0
858
859 try:
860 spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
861 cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
862 dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
863 except:
864 print "Data file %s is invalid" % self.filename
865 return 0
789
866
790 if not( self.m_ProcessingHeader.shif_fft ):
867 if not( self.m_ProcessingHeader.shif_fft ):
791 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
868 spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
@@ -799,16 +876,17 class SpectraReader( DataReader ):
799 self.__data_cspc = cspc['real'] + cspc['imag']*1j
876 self.__data_cspc = cspc['real'] + cspc['imag']*1j
800 self.__data_dc = dc['real'] + dc['imag']*1j
877 self.__data_dc = dc['real'] + dc['imag']*1j
801
878
879 self.datablock_id = 0
802 self.__flagIsNewFile = 0
880 self.__flagIsNewFile = 0
803
804 self.flagIsNewBlock = 1
881 self.flagIsNewBlock = 1
805
882
806 self.nReadBlocks += 1
883 self.nReadBlocks += 1
807 self.datablock_id = 0
884 self.nBlocks += 1
808
885
886 return 1
809
887
810
888
811 def __hasNotDataInBuffer( self ):
889 def __hasNotDataInBuffer(self):
812 #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
890 #if self.datablock_id >= self.m_ProcessingHeader.profilesPerBlock:
813 return 1
891 return 1
814
892
@@ -830,7 +908,6 class SpectraReader( DataReader ):
830 filename : el ultimo file de una determinada carpeta
908 filename : el ultimo file de una determinada carpeta
831 directory : eL directorio donde esta el file encontrado
909 directory : eL directorio donde esta el file encontrado
832 """
910 """
833
834 print "Searching files ..."
911 print "Searching files ..."
835
912
836 dirList = []
913 dirList = []
@@ -843,7 +920,7 class SpectraReader( DataReader ):
843
920
844 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
921 dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted
845 if len(dirList) > 0 :
922 if len(dirList) > 0 :
846 directory = dirList[-1]
923 directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
847 else:
924 else:
848 year = startDateTime.timetuple().tm_year
925 year = startDateTime.timetuple().tm_year
849 doy = startDateTime.timetuple().tm_yday
926 doy = startDateTime.timetuple().tm_yday
@@ -916,7 +993,6 class SpectraReader( DataReader ):
916 de leer todos los bloques de datos de un determinado
993 de leer todos los bloques de datos de un determinado
917 archivo se pasa al siguiente archivo de la lista.
994 archivo se pasa al siguiente archivo de la lista.
918 """
995 """
919
920 print "Searching files ..."
996 print "Searching files ..."
921
997
922 dirList = []
998 dirList = []
@@ -975,13 +1051,7 class SpectraReader( DataReader ):
975
1051
976 file = os.path.join( path, dirfilename, filename )
1052 file = os.path.join( path, dirfilename, filename )
977
1053
978 nTries = 0
1054 for nTries in range( self.__nTries+1 ):
979 while(True):
980
981 nTries += 1
982 if nTries > self.__nTries:
983 break
984
985 try:
1055 try:
986 fp = open( file,'rb' ) #lectura binaria
1056 fp = open( file,'rb' ) #lectura binaria
987 except:
1057 except:
@@ -991,21 +1061,24 class SpectraReader( DataReader ):
991 m_BasicHeader.read(fp)
1061 m_BasicHeader.read(fp)
992 except:
1062 except:
993 print "The file %s is empty" % filename
1063 print "The file %s is empty" % filename
994
1064
995 fp.close()
1065 fp.close()
996
1066
997 if m_BasicHeader.size > 24:
1067 if m_BasicHeader.size > 24:
998 break
1068 break
999
1069
1000 print 'waiting for new block: try %02d' % ( nTries )
1070 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1071 break
1072
1073 print '\twaiting for new block of file %s: try %02d' % ( file, nTries )
1001 time.sleep( self.__delay)
1074 time.sleep( self.__delay)
1002
1075
1003 if m_BasicHeader.size <= 24:
1076 if m_BasicHeader.size <= 24:
1004 return 0
1077 return 0
1005
1078
1006 return 1
1079 return 1
1007
1080
1008
1081
1009 def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
1082 def setup( self, path, startDateTime=None, endDateTime=None, set=None, expLabel = "", ext = ".pdata", online = 0 ):
1010 """
1083 """
1011 setup configura los parametros de lectura de la clase SpectraReader.
1084 setup configura los parametros de lectura de la clase SpectraReader.
@@ -1049,26 +1122,31 class SpectraReader( DataReader ):
1049 self.filenameList
1122 self.filenameList
1050 self.online
1123 self.online
1051 """
1124 """
1052
1053 if online:
1125 if online:
1054 nTries = 0
1126 fileOK_flag = False
1055 while( nTries < self.__nTries ):
1127 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
1056 nTries += 1
1128 file = os.path.join( path, subfolder )
1057 subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
1129
1130 for nTries in range( self.__nTries+1 ): #espera por el 1er file
1058 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1131 year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
1059 if filename == None:
1132
1060 file = os.path.join( path, subfolder )
1133 if filename != None:
1061 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries )
1134 if isFileOK( os.path.join( path,dirfilename,filename ) ):
1062 time.sleep( self.__delay )
1135 fileOK_flag = True
1063 else:
1136 break
1137
1138 if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
1064 break
1139 break
1140
1141 print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 )
1142 time.sleep( self.__delay )
1065
1143
1066 if filename == None:
1144 if not( fileOK_flag ): #filename == None:
1067 print "No files On Line"
1145 print "No files on line or invalid first file"
1068 return 0
1146 return 0
1069
1147
1070 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1148 if self.__initFilesOnline( path, dirfilename, filename ) == 0:
1071 print "The file %s hasn't enough data"
1149 print "The file %s hasn't enough data" % filename
1072 return 0
1150 return 0
1073
1151
1074 self.__year = year
1152 self.__year = year
@@ -1128,14 +1206,15 class SpectraReader( DataReader ):
1128 if not( self.__setNewBlock() ):
1206 if not( self.__setNewBlock() ):
1129 return 0
1207 return 0
1130
1208
1131 self.__readBlock()
1209 if not( self.__readBlock() ):
1210 return 0
1132
1211
1133 self.__lastUTTime = self.m_BasicHeader.utc
1212 self.__lastUTTime = self.m_BasicHeader.utc
1134
1213
1135 return 1
1214 return 1
1136
1215
1137
1216
1138 def getData( self ):
1217 def getData(self):
1139 """
1218 """
1140 Copia el buffer de lectura a la clase "Spectra",
1219 Copia el buffer de lectura a la clase "Spectra",
1141 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
1220 con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
@@ -1157,7 +1236,9 class SpectraReader( DataReader ):
1157
1236
1158 if self.__hasNotDataInBuffer():
1237 if self.__hasNotDataInBuffer():
1159
1238
1160 self.readNextBlock()
1239 if not( self.readNextBlock() ):
1240 self.__setNextFile()
1241 return 0
1161
1242
1162 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1243 self.m_Spectra.m_BasicHeader = self.m_BasicHeader.copy()
1163 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
1244 self.m_Spectra.m_ProcessingHeader = self.m_ProcessingHeader.copy()
@@ -1172,6 +1253,10 class SpectraReader( DataReader ):
1172
1253
1173 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1254 #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
1174
1255
1256 if self.__data_dc == None:
1257 self.m_Voltage.flagNoData = True
1258 return 0
1259
1175 self.m_Spectra.flagNoData = False
1260 self.m_Spectra.flagNoData = False
1176 self.m_Spectra.flagResetProcessing = self.flagResetProcessing
1261 self.m_Spectra.flagResetProcessing = self.flagResetProcessing
1177
1262
@@ -1186,13 +1271,13 class SpectraReader( DataReader ):
1186 return 1
1271 return 1
1187
1272
1188
1273
1189 class SpectraWriter( DataWriter ):
1274 class SpectraWriter(DataWriter):
1190 """
1275 """
1191 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
1276 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
1192 de los datos siempre se realiza por bloques.
1277 de los datos siempre se realiza por bloques.
1193 """
1278 """
1194
1279
1195 def __init__( self, m_Spectra = None ):
1280 def __init__(self,m_Spectra=None):
1196 """
1281 """
1197 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
1282 Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
1198
1283
@@ -1251,7 +1336,7 class SpectraWriter( DataWriter ):
1251 self.__data_cspc = None
1336 self.__data_cspc = None
1252 self.__data_dc = None
1337 self.__data_dc = None
1253
1338
1254 def __writeFirstHeader( self ):
1339 def __writeFirstHeader(self):
1255 """
1340 """
1256 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1341 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1257
1342
@@ -1267,7 +1352,8 class SpectraWriter( DataWriter ):
1267 self.__wrProcessingHeader()
1352 self.__wrProcessingHeader()
1268 self.__dataType = self.m_Spectra.dataType
1353 self.__dataType = self.m_Spectra.dataType
1269
1354
1270 def __writeBasicHeader( self, fp=None ):
1355
1356 def __writeBasicHeader(self, fp=None):
1271 """
1357 """
1272 Escribe solo el Basic header en el file creado
1358 Escribe solo el Basic header en el file creado
1273
1359
@@ -1279,7 +1365,8 class SpectraWriter( DataWriter ):
1279
1365
1280 self.m_BasicHeader.write(fp)
1366 self.m_BasicHeader.write(fp)
1281
1367
1282 def __wrSystemHeader( self, fp=None ):
1368
1369 def __wrSystemHeader(self,fp=None):
1283 """
1370 """
1284 Escribe solo el System header en el file creado
1371 Escribe solo el System header en el file creado
1285
1372
@@ -1291,7 +1378,8 class SpectraWriter( DataWriter ):
1291
1378
1292 self.m_SystemHeader.write(fp)
1379 self.m_SystemHeader.write(fp)
1293
1380
1294 def __wrRadarControllerHeader( self, fp=None ):
1381
1382 def __wrRadarControllerHeader(self,fp=None):
1295 """
1383 """
1296 Escribe solo el RadarController header en el file creado
1384 Escribe solo el RadarController header en el file creado
1297
1385
@@ -1303,7 +1391,8 class SpectraWriter( DataWriter ):
1303
1391
1304 self.m_RadarControllerHeader.write(fp)
1392 self.m_RadarControllerHeader.write(fp)
1305
1393
1306 def __wrProcessingHeader( self, fp=None ):
1394
1395 def __wrProcessingHeader(self,fp=None):
1307 """
1396 """
1308 Escribe solo el Processing header en el file creado
1397 Escribe solo el Processing header en el file creado
1309
1398
@@ -1314,8 +1403,9 class SpectraWriter( DataWriter ):
1314 fp = self.__fp
1403 fp = self.__fp
1315
1404
1316 self.m_ProcessingHeader.write(fp)
1405 self.m_ProcessingHeader.write(fp)
1406
1317
1407
1318 def __setNextFile( self ):
1408 def __setNextFile(self):
1319 """
1409 """
1320 Determina el siguiente file que sera escrito
1410 Determina el siguiente file que sera escrito
1321
1411
@@ -1336,7 +1426,7 class SpectraWriter( DataWriter ):
1336 if self.__fp != None:
1426 if self.__fp != None:
1337 self.__fp.close()
1427 self.__fp.close()
1338
1428
1339 if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1429 #if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
1340
1430
1341 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
1431 timeTuple = time.localtime(self.m_Spectra.m_BasicHeader.utc) # utc from m_Spectra
1342 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1432 subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
@@ -1383,7 +1473,8 class SpectraWriter( DataWriter ):
1383
1473
1384 return 1
1474 return 1
1385
1475
1386 def __setNewBlock( self ):
1476
1477 def __setNewBlock(self):
1387 """
1478 """
1388 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1479 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1389
1480
@@ -1406,7 +1497,8 class SpectraWriter( DataWriter ):
1406
1497
1407 return 1
1498 return 1
1408
1499
1409 def __writeBlock( self ):
1500
1501 def __writeBlock(self):
1410 """
1502 """
1411 Escribe el buffer en el file designado
1503 Escribe el buffer en el file designado
1412
1504
@@ -1448,15 +1540,12 class SpectraWriter( DataWriter ):
1448 self.__data_dc.fill(0)
1540 self.__data_dc.fill(0)
1449
1541
1450 self.__flagIsNewFile = 0
1542 self.__flagIsNewFile = 0
1451
1452 self.flagIsNewBlock = 1
1543 self.flagIsNewBlock = 1
1453
1454 self.nWriteBlocks += 1
1544 self.nWriteBlocks += 1
1455
1456 self.__blocksCounter += 1
1545 self.__blocksCounter += 1
1457
1546
1458
1547
1459 def writeNextBlock( self ):
1548 def writeNextBlock(self):
1460 """
1549 """
1461 Selecciona el bloque siguiente de datos y los escribe en un file
1550 Selecciona el bloque siguiente de datos y los escribe en un file
1462
1551
@@ -1468,15 +1557,14 class SpectraWriter( DataWriter ):
1468 return 0
1557 return 0
1469
1558
1470 self.__writeBlock()
1559 self.__writeBlock()
1471
1472 return 1
1560 return 1
1473
1561
1474
1562
1475 def __hasAllDataInBuffer( self ):
1563 def __hasAllDataInBuffer(self):
1476 return 1
1564 return 1
1477
1565
1478
1566
1479 def putData( self ):
1567 def putData(self):
1480 """
1568 """
1481 Setea un bloque de datos y luego los escribe en un file
1569 Setea un bloque de datos y luego los escribe en un file
1482
1570
@@ -1505,7 +1593,6 class SpectraWriter( DataWriter ):
1505 self.__data_dc = self.m_Spectra.data_dc
1593 self.__data_dc = self.m_Spectra.data_dc
1506
1594
1507 if True:
1595 if True:
1508 #time.sleep( 3 )
1509 self.__getHeader()
1596 self.__getHeader()
1510 self.writeNextBlock()
1597 self.writeNextBlock()
1511
1598
@@ -1515,7 +1602,7 class SpectraWriter( DataWriter ):
1515
1602
1516 return 1
1603 return 1
1517
1604
1518 def __getHeader( self ):
1605 def __getHeader(self):
1519 """
1606 """
1520 Obtiene una copia del First Header
1607 Obtiene una copia del First Header
1521
1608
@@ -1536,7 +1623,7 class SpectraWriter( DataWriter ):
1536 self.__dataType = self.m_Spectra.dataType
1623 self.__dataType = self.m_Spectra.dataType
1537
1624
1538
1625
1539 def __setHeaderByFile( self ):
1626 def __setHeaderByFile(self):
1540
1627
1541 format = self.__format
1628 format = self.__format
1542 header = ['Basic','System','RadarController','Processing']
1629 header = ['Basic','System','RadarController','Processing']
@@ -1616,7 +1703,7 class SpectraWriter( DataWriter ):
1616 sys.exit(0)
1703 sys.exit(0)
1617
1704
1618
1705
1619 def setup( self, path, format='pdata' ):
1706 def setup(self,path,format='pdata'):
1620 """
1707 """
1621 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1708 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1622
1709
General Comments 0
You need to be logged in to leave comments. Login now