schain Commit - r163:dc0275970b25 · Jicamarca Repository

avance spectros en alturas

Alexander Valdez -

r163:dc0275970b25

parent child

Context file:

r163:dc0275970b25

Collapse all files

schainpy2/IO/SpectraIO.py +128 -4

             '''
             $Author$
             $Id$
             '''
             import os, sys
             import numpy
+            import pyfits
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from JROHeaderIO import *
             from JRODataIO import JRODataReader
             from JRODataIO import JRODataWriter
             from Data.JROData import Spectra
+            from Data.JROData import SpectraHeis
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
                 dataOutObj = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOutObj    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOutObj
                     Return      : None
                     """
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 3   #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOutObj.nChannels
                         self.dataOutObj.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not(self.processingHeaderObj.shif_fft):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         if self.processingHeaderObj.flag_cspc:
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     Copia el buffer de lectura a la clase "Spectra",
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
                         self.dataOutObj
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
             #            self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
                         self.dataOutObj.flagNoData = True
                         return 0
                     self.dataOutObj.data_spc = self.data_spc
                     self.dataOutObj.data_cspc = self.data_cspc
                     self.dataOutObj.data_dc = self.data_dc
                     self.dataOutObj.flagTimeBlock = self.flagTimeBlock
                     self.dataOutObj.flagNoData = False
                     self.dataOutObj.dtype = self.dtype
                     self.dataOutObj.nChannels = self.nRdChannels
                     self.dataOutObj.nPairs = self.nRdPairs
                     self.dataOutObj.pairsList = self.rdPairList
                     self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
                     self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOutObj.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOutObj.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
                     self.dataOutObj.ippSeconds = self.ippSeconds
                     self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOutObj.nFFTPoints
                     self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     return self.dataOutObj.data_spc
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".pdata"
                 optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 wrPairList = []
                 nWrPairs = 0
                 nWrChannels = 0
             #    dataOutObj = None
                 def __init__(self, dataOutObj=None):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOutObj
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     if not( isinstance(dataOutObj, Spectra) ):
                         raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
                     self.dataOutObj = dataOutObj
                     self.nTotalBlocks = 0
                     self.nWrChannels = self.dataOutObj.nChannels
             #        if len(pairList) > 0:
             #            self.wrPairList = pairList
             #
             #            self.nWrPairs = len(pairList)
                     self.wrPairList = self.dataOutObj.pairsList
                     self.nWrPairs = self.dataOutObj.nPairs
             #        self.data_spc = None
             #        self.data_cspc = None
             #        self.data_dc = None
             #        self.fp = None
             #        self.flagIsNewFile = 1
             #
             #        self.nTotalBlocks = 0
             #
             #        self.flagIsNewBlock = 0
             #
             #        self.flagNoMoreFiles = 0
             #
             #        self.setFile = None
             #
             #        self.dtype = None
             #
             #        self.path = None
             #
             #        self.noMoreFiles = 0
             #
             #        self.filename = None
             #
             #        self.basicHeaderObj = BasicHeader()
             #
             #        self.systemHeaderObj = SystemHeader()
             #
             #        self.radarControllerHeaderObj = RadarControllerHeader()
             #
             #        self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOutObj.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.dataOutObj.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     if self.data_dc != None:
                         data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                         dc = self.data_dc
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.dataOutObj.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.getBasicHeader()
                     self.data_spc = self.dataOutObj.data_spc
                     self.data_cspc = self.dataOutObj.data_cspc
                     self.data_dc = self.dataOutObj.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
                         if self.dataOutObj.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOutObj.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOutObj.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOutObj.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOutObj.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                     if self.dataOutObj.data_dc != None:
                         processFlags += PROCFLAG.SAVE_CHANNELS_DC
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
                         if self.dataOutObj.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
                     pts2write_SelfSpectra = int(self.nWrChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
                     if self.dataOutObj.data_cspc != None:
                         pts2write_CrossSpectra = int(self.nWrPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
                     if self.dataOutObj.data_dc != None:
                         pts2write_DCchannels = int(self.nWrChannels * self.dataOutObj.nHeights)
                         blocksize += (pts2write_DCchannels*datatypeValue*2)
                     blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def getBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOutObj.utctime)
                     milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = 0
                     self.basicHeaderObj.dstFlag = 0
                     self.basicHeaderObj.errorCount = 0
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
                     self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOutObj.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOutObj.nPairs + self.dataOutObj.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOutObj.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         for pair in self.dataOutObj.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb,dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
                     if self.dataOutObj.code != None:
                         self.processingHeaderObj.code = self.dataOutObj.code
                         self.processingHeaderObj.nCode = self.dataOutObj.nCode
                         self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
                         sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOutObj.nCode * self.dataOutObj.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                         sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
                         processingHeaderSize += sizeOfWindows
                     self.processingHeaderObj.size = processingHeaderSize
+            class FITS:
+                name=None
+                format=None
+                array =None
+                data =None
+                thdulist=None
+                def __init__(self):
+                    pass
+                def setColF(self,name,format,array):
+                    self.name=name
+                    self.format=format
+                    self.array=array
+                    a1=numpy.array([self.array],dtype=numpy.float32)
+                    self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
+                    return self.col1
+            #    def setColP(self,name,format,data):
+            #        self.name=name
+            #        self.format=format
+            #        self.data=data
+            #        a2=numpy.array([self.data],dtype=numpy.float32)
+            #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
+            #        return self.col2
+                def writeHeader(self,):
+                    pass
+                def writeData(self,name,format,data):
+                    self.name=name
+                    self.format=format
+                    self.data=data
+                    a2=numpy.array([self.data],dtype=numpy.float32)
+                    self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
+                    return self.col2
+                def cFImage(self,n):
+                    self.hdu= pyfits.PrimaryHDU(n)
+                    return self.hdu
+                def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
+                    self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
+                    self.tbhdu = pyfits.new_table(self.cols)
+                    return self.tbhdu
+                def CFile(self,hdu,tbhdu):
+                    self.thdulist=pyfits.HDUList([hdu,tbhdu])
+                def wFile(self,filename):
+                    self.thdulist.writeto(filename)
+            class SpectraHeisWriter():
+                i=0
+                def __init__(self, dataOutObj):
+                    self.wrObj = FITS()
+                    self.dataOutObj = dataOutObj
+                def isNumber(str):
+                    """
+                    Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
+                    Excepciones:
+                    Si un determinado string no puede ser convertido a numero
+                    Input:
+                    str, string al cual se le analiza para determinar si convertible a un numero o no
+                    Return:
+                    True    :    si el string es uno numerico
+                    False   :    no es un string numerico
+                    """
+                    try:
+                        float( str )
+                        return True
+                    except:
+                        return False
+                def setup(self, wrpath,):
+                    if not(os.path.exists(wrpath)):
+                        os.mkdir(wrpath)
+                    self.wrpath = wrpath
+                    self.setFile = 0
+                def putData(self):
+                  # self.wrObj.writeHeader(nChannels=self.dataOutObj.nChannels, nFFTPoints=self.dataOutObj.nFFTPoints)
+                    #name = self.dataOutObj.utctime
+                    name= time.localtime( self.dataOutObj.utctime)
+                    ext=".fits"
+                    #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
+                    subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
+                    doypath = os.path.join( self.wrpath, subfolder )
+                    if not( os.path.exists(doypath) ):
+                        os.mkdir(doypath)
+                    self.setFile += 1
+                    file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
+                    filename = os.path.join(self.wrpath,subfolder, file)
+                   # print self.dataOutObj.ippSeconds
+                    freq=numpy.arange(-1*self.dataOutObj.nHeights/2.,self.dataOutObj.nHeights/2.)/(2*self.dataOutObj.ippSeconds)
+                    col1=self.wrObj.setColF(name="freq", format=str(self.dataOutObj.nFFTPoints)+'E', array=freq)
+                    col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[0,:]))
+                    col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[1,:]))
+                    col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[2,:]))
+                    col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[3,:]))
+                    col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[4,:]))
+                    col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[5,:]))
+                    col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[6,:]))
+                    col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[7,:]))
+                    #n=numpy.arange((100))
+                    n=self.dataOutObj.data_spc[6,:]
+                    a=self.wrObj.cFImage(n)
+                    b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
+                    self.wrObj.CFile(a,b)
+                    self.wrObj.wFile(filename)
+                    return 1
+  No newline at end of file

schainpy2/Processing/SpectraProcessor.py +33 0

             '''
             $Author$
             $Id$
             '''
             import os, sys
             import numpy
             import time
             import datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Data.JROData import Spectra, SpectraHeis
             from IO.SpectraIO import SpectraWriter
             from Graphics.schainPlotTypes import ScopeFigure, SpcFigure, RTIFigure
             #from JRONoise import Noise
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 noiseObj = None
                 integratorObjList = []
                 writerObjList = []
                 integratorObjIndex = None
                 writerObjIndex = None
                 profIndex = 0 # Se emplea cuando el objeto de entrada es un Voltage
                 firstdatatime = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.integratorObjIndex = None
                     self.writerObjIndex = None
                     self.plotObjIndex = None
                     self.integratorOst = []
                     self.plotObjList = []
                     self.noiseObj = []
                     self.writerObjList = []
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairsList=None):
                     if dataInObj == None:
                         raise ValueError, "This SpectraProcessor.setup() function needs dataInObj input variable"
                     if dataInObj.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProcessor.setup() function needs nFFTPoints input variable"
                     if dataInObj.type == "Spectra":
                         if nFFTPoints != None:
                             raise ValueError, "The nFFTPoints cannot be selected to this object type"
                         nFFTPoints = dataInObj.nFFTPoints
                         if pairsList == None:
                             pairsList = dataInObj.pairsList
                     if pairsList == None:
                         nPairs = 0
                     else:
                         nPairs = len(pairsList)
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     self.dataOutObj = dataOutObj
                     self.dataOutObj.nFFTPoints = nFFTPoints
                     self.dataOutObj.pairsList = pairsList
                     self.dataOutObj.nPairs = nPairs
                     return self.dataOutObj
                 def init(self):
                     self.dataOutObj.flagNoData = True
                     if self.dataInObj.flagNoData:
                         return 0
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
                     if self.dataInObj.type == "Spectra":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
                     if self.dataInObj.type == "Voltage":
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.dataInObj.nChannels,
                                                        self.dataOutObj.nFFTPoints,
                                                        self.dataInObj.nHeights),
                                                       dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataInObj.utctime
                         if self.profIndex == self.dataOutObj.nFFTPoints:
                             self.__updateObjFromInput()
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
                             self.firstdatatime = None
                             self.profIndex = 0
                         return
                     #Other kind of data
                     raise ValueError, "The type object %(s) is not valid " %(self.dataOutObj.type)
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.m_BasicHeader
                         self.dataOutObj.m_ProcessingHeader
                         self.dataOutObj.radarControllerHeaderObj
                         self.dataOutObj.systemHeaderObj
                         self.profIndex
                         self.buffer
                         self.dataOutObj.flagNoData
                         self.dataOutObj.dtype
                         self.dataOutObj.nPairs
                         self.dataOutObj.nChannels
                         self.dataOutObj.nProfiles
                         self.dataOutObj.systemHeaderObj.numChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_ProcessingHeader.profilesPerBlock
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOutObj.pairsList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOutObj.nPairs, self.dataOutObj.nFFTPoints, self.dataOutObj.nHeights), dtype='complex')
                         for pair in self.dataOutObj.pairsList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.blockSize = blocksize
             #        self.getNoise()
                 def __updateObjFromInput(self):
                     self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
                     self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
                     self.dataOutObj.channelList = self.dataInObj.channelList
                     self.dataOutObj.heightList = self.dataInObj.heightList
                     self.dataOutObj.dtype = self.dataInObj.dtype
                     self.dataOutObj.nHeights = self.dataInObj.nHeights
                     self.dataOutObj.nChannels = self.dataInObj.nChannels
                     self.dataOutObj.nBaud = self.dataInObj.nBaud
                     self.dataOutObj.nCode = self.dataInObj.nCode
                     self.dataOutObj.code = self.dataInObj.code
                     self.dataOutObj.nProfiles = self.dataOutObj.nFFTPoints
                     self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
                     self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
                     self.dataOutObj.utctime = self.firstdatatime
                     self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
                     self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
                     self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
                     self.dataOutObj.nCohInt = self.dataInObj.nCohInt
                     self.dataOutObj.nIncohInt = 1
                     self.dataOutObj.ippSeconds = self.dataInObj.ippSeconds
                     self.dataOutObj.timeInterval = self.dataInObj.timeInterval*self.dataOutObj.nFFTPoints
                 def addWriter(self, wrpath, blocksPerFile):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath, blocksPerFile)
                     self.writerObjList.append(objWriter)
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def addCrossSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     crossSpcObj = CrossSpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(crossSpcObj)
                 def plotCrossSpc(self, idfigure=None,
                                 xmin=None,
                                 xmax=None,
                                 ymin=None,
                                 ymax=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
                                 colormap='br_green',
                                 colorbar=True,
                                 showprofile=False,
                                 save=False,
                                 gpath=None,
                                 pairsList = None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if pairsList == None:
                         pairsList = self.dataOutObj.pairsList
                     nframes = len(pairsList)
                     x = numpy.arange(self.dataOutObj.nFFTPoints)
                     y = self.dataOutObj.heightList
                     data_spc = self.dataOutObj.data_spc
                     data_cspc = self.dataOutObj.data_cspc
                     data = []
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                 def addRti(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     rtiObj = RTIFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(rtiObj)
                 def plotRti(self, idfigure=None,
                                 starttime=None,
                                 endtime=None,
                                 rangemin=None,
                                 rangemax=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
                                 colormap='br_greeen',
                                 colorbar=True,
                                 showprofile=False,
                                 xrangestep=None,
                                 save=False,
                                 gpath=None,
                                 ratio=1,
                                 channelList=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if channelList == None:
                         channelList = self.dataOutObj.channelList
                     nframes = len(channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addRti(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
                     data = numpy.average(data, axis=1)
                     currenttime = self.dataOutObj.utctime - time.timezone
                     range = self.dataOutObj.heightList
                     figuretitle = "RTI Plot for Spectra Data" #+ date
                     cleardata = False
                     deltax = self.dataOutObj.timeInterval
                     plotObj = self.plotObjList[self.plotObjIndex]
                     plotObj.plotPcolor(data=data,
                                        x=currenttime,
                                        y=range,
                                        channelList=channelList,
                                        xmin=starttime,
                                        xmax=endtime,
                                        ymin=rangemin,
                                        ymax=rangemax,
                                        minvalue=minvalue,
                                        maxvalue=maxvalue,
                                        figuretitle=figuretitle,
                                        xrangestep=xrangestep,
                                        deltax=deltax,
                                        save=save,
                                        gpath=gpath,
                                        ratio=ratio,
                                        cleardata=cleardata
                                        )
                     self.plotObjIndex += 1
                 def addSpc(self, idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile):
                     spcObj = SpcFigure(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     self.plotObjList.append(spcObj)
                 def plotSpc(self, idfigure=None,
                                 xmin=None,
                                 xmax=None,
                                 ymin=None,
                                 ymax=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 wintitle='',
                                 driver='plplot',
                                 colormap='br_green',
                                 colorbar=True,
                                 showprofile=False,
                                 save=False,
                                 gpath=None,
                                 ratio=1,
                                 channelList=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if channelList == None:
                         channelList = self.dataOutObj.channelList
                     nframes = len(channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addSpc(idfigure, nframes, wintitle, driver, colormap, colorbar, showprofile)
                     x = numpy.arange(self.dataOutObj.nFFTPoints)
                     y = self.dataOutObj.heightList
                     data = 10.*numpy.log10(self.dataOutObj.data_spc[channelList,:,:])
             #        noisedB = 10.*numpy.log10(noise)
                     noisedB = numpy.arange(len(channelList)+1)
                     noisedB = noisedB *1.2
                     titleList = []
                     for i in range(len(noisedB)):
                         title = "%.2f"%noisedB[i]
                         titleList.append(title)
                     thisdatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisdatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     figuretitle = "Spc Radar Data: %s"%dateTime
                     cleardata = True
                     plotObj = self.plotObjList[self.plotObjIndex]
                     plotObj.plotPcolor(data=data,
                                         x=x,
                                         y=y,
                                         channelList=channelList,
                                         xmin=xmin,
                                         xmax=xmax,
                                         ymin=ymin,
                                         ymax=ymax,
                                         minvalue=minvalue,
                                         maxvalue=maxvalue,
                                         figuretitle=figuretitle,
                                         xrangestep=None,
                                         deltax=None,
                                         save=save,
                                         gpath=gpath,
                                         cleardata=cleardata
                                         )
                     self.plotObjIndex += 1
                 def writeData(self, wrpath, blocksPerFile):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath, blocksPerFile)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,datatime=self.dataOutObj.utctime)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.timeInterval *= myCohIntObj.nIncohInt
                         self.dataOutObj.nIncohInt = myIncohIntObj.navg * self.dataInObj.nIncohInt
                         self.dataOutObj.utctime = myIncohIntObj.firstdatatime
                         self.dataOutObj.flagNoData = False
                         """Calcular el ruido"""
                         self.getNoise()
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
             class SpectraHeisProcessor:
                 def __init__(self):
                     self.integratorObjIndex = None
                     self.writerObjIndex = None
                     self.plotObjIndex = None
                     self.integratorObjList = []
                     self.writerObjList = []
                     self.plotObjList = []
                     #self.noiseObj = Noise()
                 def setup(self, dataInObj, dataOutObj=None, nFFTPoints=None, pairList=None):
                     if nFFTPoints == None:
                         nFFTPoints = self.dataInObj.nHeights
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = SpectraHeis()
                     self.dataOutObj = dataOutObj
                     return self.dataOutObj
                 def init(self):
                     self.dataOutObj.flagNoData = True
                     if self.dataInObj.flagNoData:
                         return 0
                     self.integratorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotObjIndex = 0
                     if self.dataInObj.type == "Voltage":
                         self.__updateObjFromInput()
                         self.__getFft()
                         self.dataOutObj.flagNoData = False
                         return
                     #Other kind of data
                     if self.dataInObj.type == "SpectraHeis":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
                     raise ValueError, "The type is not valid"
                 def __updateObjFromInput(self):
                     self.dataOutObj.radarControllerHeaderObj = self.dataInObj.radarControllerHeaderObj.copy()
                     self.dataOutObj.systemHeaderObj = self.dataInObj.systemHeaderObj.copy()
                     self.dataOutObj.channelList = self.dataInObj.channelList
                     self.dataOutObj.heightList = self.dataInObj.heightList
                     self.dataOutObj.dtype = self.dataInObj.dtype
                     self.dataOutObj.nHeights = self.dataInObj.nHeights
                     self.dataOutObj.nChannels = self.dataInObj.nChannels
                     self.dataOutObj.nBaud = self.dataInObj.nBaud
                     self.dataOutObj.nCode = self.dataInObj.nCode
                     self.dataOutObj.code = self.dataInObj.code
                     self.dataOutObj.nProfiles = 1
                     self.dataOutObj.nFFTPoints = self.dataInObj.nHeights
                     self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
                     self.dataOutObj.flagNoData = self.dataInObj.flagNoData
                     self.dataOutObj.flagTimeBlock = self.dataInObj.flagTimeBlock
                     self.dataOutObj.utctime = self.dataInObj.utctime
                     self.dataOutObj.flagDecodeData = self.dataInObj.flagDecodeData #asumo q la data esta decodificada
                     self.dataOutObj.flagDeflipData = self.dataInObj.flagDeflipData #asumo q la data esta sin flip
                     self.dataOutObj.flagShiftFFT = self.dataInObj.flagShiftFFT
                     self.dataOutObj.nIncohInt = 1
+                    self.dataOutObj.ippSeconds= self.dataInObj.ippSeconds
+              #  def addWriter(self,wrpath,blocksPerfile):
+                def addWriter(self,wrpath):
+                    objWriter=SpectraHeisWriter(self.dataOutObj)
+                    objWriter.setup(wrpath)
+                    #objWriter.setup(wrpath,blocksPerfile)
+                    self.writerObjList.append(objWriter)
+               # def writedata(self,wrpath,blocksPerfile):
+                def writedata(self,wrpath):
+                    if self.dataOutObj.flagNoData:
+                        return 0
+                    if len(self.writerObjList) <= self.writerObjIndex:
+                        #self.addWriter(wrpath, blocksPerFile)
+                        self.addWriter(wrpath)
+                    self.writerObjList[self.writerObjIndex].putData()
+                    self.writerObjIndex += 1
                 def __getFft(self):
                     fft_volt = numpy.fft.fft(self.dataInObj.data, axis=1)
                     #print fft_volt
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
                     self.dataOutObj.data_spc = spc
                 def getSpectra(self):
                     return self.dataOutObj.data_spc
                 def getFrecuencies(self):
                     print self.nFFTPoints
                     return numpy.arange(int(self.nFFTPoints))
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.utctime)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.nIncohInt = self.dataOutObj.nIncohInt*myIncohIntObj.navg
                         self.dataOutObj.flagNoData = False
                         #self.getNoise(type="hildebrand",parm=myIncohIntObj.navg)
             #            self.getNoise(type="sort", parm=16)
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
                 def addScope(self, idfigure, nframes, wintitle, driver):
                     if idfigure==None:
                         idfigure = self.plotObjIndex
                     scopeObj = ScopeFigure(idfigure, nframes, wintitle, driver)
                     self.plotObjList.append(scopeObj)
                 def plotScope(self,
                                 idfigure=None,
                                 minvalue=None,
                                 maxvalue=None,
                                 xmin=None,
                                 xmax=None,
                                 wintitle='',
                                 driver='plplot',
                                 save=False,
                                 gpath=None,
                                 titleList=None,
                                 xlabelList=None,
                                 ylabelList=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     nframes = len(self.dataOutObj.channelList)
                     if len(self.plotObjList) <= self.plotObjIndex:
                         self.addScope(idfigure, nframes, wintitle, driver)
                     data1D = self.dataOutObj.data_spc
                     x = numpy.arange(self.dataOutObj.nHeights)
                     thisDatetime = datetime.datetime.fromtimestamp(self.dataOutObj.utctime)
                     dateTime = "%s"%(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     date = "%s"%(thisDatetime.strftime("%d-%b-%Y"))
                     figureTitle = "Scope Plot Radar Data: " + date
                     plotObj = self.plotObjList[self.plotObjIndex]
                     plotObj.plot1DArray(data1D,
                                          x,
                                          self.dataOutObj.channelList,
                                          xmin,
                                          xmax,
                                          minvalue,
                                          maxvalue,
                                          figureTitle,
                                          save,
                                          gpath)
                     self.plotObjIndex += 1
+                def rti(self):
+                    if self.dataOutObj.flagNoData:
+                       return 0
+                    data=numpy.average(self.dataOutObj.data_spc,axis=1)
+                    data[0]
+                    print data[0]
+                    x = numpy.arange(100000)
+                    print "test"
+                    #print self.dataOutObj.data_spc.average(axis=1)
             class IncoherentIntegration:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nIncohInt = None
                 firstdatatime = None
                 def __init__(self, N = None, timeInterval = None):
                     """
                     N
                     timeInterval - interval time [min], integer value
                     """
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nIncohInt = N
                     self.integ_counter = 0
                     self.firstdatatime = None
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                     if ((timeInterval==None) and (N==None)):
                          print 'N = None ; timeInterval = None'
                          sys.exit(0)
                     elif timeInterval == None:
                         self.timeFlag = False
                     else:
                         self.timeFlag = True
                 def exe(self,data,datatime):
                     """
                     data
                     datatime [seconds]
                     """
                     if self.firstdatatime == None or self.isReady:
                         self.firstdatatime = datatime
                     if self.timeFlag:
                         if self.timeOut == None:
                             self.timeOut = datatime + self.timeIntervalInSeconds
                         if datatime < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         else:
                             self.exitCondition = True
                     else:
                         if self.integ_counter < self.nIncohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nIncohInt:
                             self.exitCondition = True
                     if self.exitCondition:
                         self.data = self.buffer
                         self.navg = self.integ_counter
                         self.isReady = True
                         self.buffer = None
                         self.timeOut = None
                         self.integ_counter = 0
                         self.exitCondition = False
                         if self.timeFlag:
                             self.buffer = data
                             self.timeOut = datatime + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
   No newline at end of file

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages