schain Commit - r73:ea60e7ccc5aa · Jicamarca Repository

Se ha definido que el arreglo de datos debe tener el formato [canales, perfiles, alturas]; se han modificado los metodos de lectura, escritura, ploteo, procesamiento que estan relacionados.

Daniel Valdez -

r73:ea60e7ccc5aa

parent child

Context file:

r73:ea60e7ccc5aa

Collapse all files

schainpy/Graphics/SpectraPlot.py +1 -1

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import datetime
             import plplot
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Spectra import Spectra
             class Spectrum():
                 def __init__(self, Spectra, index=0):
                     """
                     Inputs:
                         type:   "power" ->> Potencia
                                 "iq"    ->> Real + Imaginario
                     """
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.nGraphs = 0
                     self.indexPlot = index
                     self.graphObjList = []
                     self.m_Spectra = Spectra
                 def __addGraph(self, subpage, title="", xlabel="", ylabel="", showColorbar=False, showPowerProfile=True, XAxisAsTime=False):
                     graphObj = ColorPlot()
                     graphObj.setup(subpage,
                                    title,
                                    xlabel,
                                    ylabel,
                                    showColorbar=showColorbar,
                                    showPowerProfile=showPowerProfile,
                                    XAxisAsTime=XAxisAsTime)
                     self.graphObjList.append(graphObj)
                 def setup(self, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False):
                     nChan = int(self.m_Spectra.m_SystemHeader.numChannels)
                     channels = range(nChan)
                     myXlabel = "Radial Velocity (m/s)"
                     myYlabel = "Range (km)"
                     for i in channels:
                         if titleList != None:
                             myTitle = titleList[i]
                             myXlabel = xlabelList[i]
                             myYlabel = ylabelList[i]
             #            if self.m_Spectra.m_NoiseObj != None:
             #                noise = '%4.2fdB' %(self.m_Spectra.m_NoiseObj[i])
             #            else:
                         noise = '--'
                         myTitle = "Channel: %d - Noise: %s" %(i, noise)
                         self.__addGraph(i+1,
                                         title=myTitle,
                                         xlabel=myXlabel,
                                         ylabel=myYlabel,
                                         showColorbar=showColorbar,
                                         showPowerProfile=showPowerProfile,
                                         XAxisAsTime=XAxisAsTime)
                     self.nGraphs = nChan
                     self.__isPlotConfig = True
                 def iniPlot(self, winTitle=""):
                     nx = int(numpy.sqrt(self.nGraphs)+1)
                     #ny = int(self.nGraphs/nx)
                     plplot.plsstrm(self.indexPlot)
                     plplot.plparseopts([winTitle], plplot.PL_PARSE_FULL)
                     plplot.plsetopt("geometry", "%dx%d" %(300*nx, 240*nx))
                     plplot.plsdev("xwin")
                     plplot.plscolbg(255,255,255)
                     plplot.plscol0(1,0,0,0)
                     plplot.plinit()
                     plplot.plspause(False)
                     plplot.pladv(0)
                     plplot.plssub(nx, nx)
                     self.__nx = nx
                     self.__ny = nx
                     self.__isPlotIni = True
                 def plotData(self, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False, winTitle="Spectra"):
                     if not(self.__isPlotConfig):
                         self.setup(titleList,
                                    xlabelList,
                                    ylabelList,
                                    showColorbar,
                                    showPowerProfile,
                                    XAxisAsTime)
                     if not(self.__isPlotIni):
                         self.iniPlot(winTitle)
                     plplot.plsstrm(self.indexPlot)
                     data = 10.*numpy.log10(self.m_Spectra.data_spc)
                     #data.shape = Channels x Heights x Profiles
-                    data = numpy.transpose( data, (0,2,1) )
+            #        data = numpy.transpose( data, (0,2,1) )
                     #data.shape = Channels x Profiles x Heights
                     nChan, nX, nY = numpy.shape(data)
                     x = numpy.arange(nX)
                     y = self.m_Spectra.heights
                     thisDatetime = datetime.datetime.fromtimestamp(self.m_Spectra.m_BasicHeader.utc)
                     txtDate = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     if xmin == None: xmin = x[0]
                     if xmax == None: xmax = x[-1]
                     if ymin == None: ymin = y[0]
                     if ymax == None: ymax = y[-1]
                     if zmin == None: zmin = numpy.nanmin(abs(data))
                     if zmax == None: zmax = numpy.nanmax(abs(data))
                     plplot.plbop()
                     plplot.plssub(self.__nx, self.__ny)
                     for i in range(self.nGraphs):
                         self.graphObjList[i].iniSubpage()
                         self.graphObjList[i].plotData(data[i,:,:],
                                                       x,
                                                       y,
                                                       xmin=xmin,
                                                       xmax=xmax,
                                                       ymin=ymin,
                                                       ymax=ymax,
                                                       zmin=zmin,
                                                       zmax=zmax)
                     plplot.plssub(1,0)
                     plplot.pladv(0)
                     plplot.plvpor(0., 1., 0., 1.)
                     plplot.plmtex("t",-1., 0.5, 0.5, txtDate)
                     plplot.plflush()
                     plplot.pleop()
                 def end(self):
                     plplot.plend()
             if __name__ == '__main__':
                 pass

schainpy/Graphics/VoltagePlot.py +9 -9

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import plplot
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Graphics.BaseGraph import *
             from Model.Voltage import Voltage
             class Osciloscope():
                 def __init__(self, Voltage, index=0):
                     """
                     Inputs:
                         type:   "power" ->> Potencia
                                 "iq"    ->> Real + Imaginario
                     """
                     self.__isPlotConfig = False
                     self.__isPlotIni = False
                     self.__xrange = None
                     self.__yrange = None
                     self.m_Voltage = None
                     self.nGraphs = 0
                     self.indexPlot = index
                     self.graphObjList = []
                     self.m_Voltage = Voltage
                 def __addGraph(self, subpage, title="", xlabel="", ylabel="", XAxisAsTime=False):
                     graphObj = LinearPlot()
                     graphObj.setup(subpage, title="", xlabel="", ylabel="", XAxisAsTime=False)
                     #graphObj.setScreenPos()
                     self.graphObjList.append(graphObj)
                     del graphObj
             #    def setXRange(self, xmin, xmax):
             #        self.__xrange = (xmin, xmax)
             #
             #    def setYRange(self, ymin, ymax):
             #        self.__yrange = (ymin, ymax)
                 def setup(self, titleList=None, xlabelList=None, ylabelList=None, XAxisAsTime=False):
                     nChan = int(self.m_Voltage.m_SystemHeader.numChannels)
                     myTitle = ""
                     myXlabel = ""
                     myYlabel = ""
-                    for i in range(nChan):
+                    for chan in range(nChan):
                         if titleList != None:
-                            myTitle = titleList[i]
+                            myTitle = titleList[chan]
-                            myXlabel = xlabelList[i]
+                            myXlabel = xlabelList[chan]
-                            myYlabel = ylabelList[i]
+                            myYlabel = ylabelList[chan]
-                        self.__addGraph(i+1, title=myTitle, xlabel=myXlabel, ylabel=myYlabel, XAxisAsTime=XAxisAsTime)
+                        self.__addGraph(chan+1, title=myTitle, xlabel=myXlabel, ylabel=myYlabel, XAxisAsTime=XAxisAsTime)
                     self.nGraphs = nChan
                     self.__isPlotConfig = True
                 def iniPlot(self, winTitle=""):
                     plplot.plsstrm(self.indexPlot)
                     plplot.plparseopts([winTitle], plplot.PL_PARSE_FULL)
                     plplot.plsetopt("geometry", "%dx%d" %(700, 115*self.nGraphs))
                     plplot.plsdev("xwin")
                     plplot.plscolbg(255,255,255)
                     plplot.plscol0(1,0,0,0)
                     plplot.plinit()
                     plplot.plspause(False)
                     plplot.plssub(1, self.nGraphs)
                     self.__isPlotIni = True
                 def plotData(self, xmin=None, xmax=None, ymin=None, ymax=None, idProfile=None, titleList=None, xlabelList=None, ylabelList=None, XAxisAsTime=False, type='iq', winTitle="Voltage"):
                     if idProfile != None and idProfile != self.m_Voltage.idProfile:
                         return
                     if not(self.__isPlotConfig):
                         self.setup(titleList, xlabelList, ylabelList, XAxisAsTime)
                     if not(self.__isPlotIni):
                         self.iniPlot(winTitle)
                     plplot.plsstrm(self.indexPlot)
                     data = self.m_Voltage.data
                     x = self.m_Voltage.heights
                     if xmin == None: xmin = x[0]
                     if xmax == None: xmax = x[-1]
                     if ymin == None: ymin = numpy.nanmin(abs(data))
                     if ymax == None: ymax = numpy.nanmax(abs(data))
                     plplot.plbop()
-                    for i in range(self.nGraphs):
+                    for chan in range(self.nGraphs):
-                        y = data[:,i]
+                        y = data[chan,:]
-                        self.graphObjList[i].iniSubpage()
+                        self.graphObjList[chan].iniSubpage()
-                        self.graphObjList[i].plotComplexData(x, y, xmin, xmax, ymin, ymax, 8, type)
+                        self.graphObjList[chan].plotComplexData(x, y, xmin, xmax, ymin, ymax, 8, type)
                     plplot.plflush()
                     plplot.pleop()
                 def end(self):
                     plplot.plend()
             class VoltagePlot(object):
                 '''
                 classdocs
                 '''
                 __m_Voltage = None
                 def __init__(self, m_Voltage):
                     '''
                     Constructor
                     '''
                     self.__m_Voltage = m_Voltage
                 def setup(self):
                     pass
                 def addGraph(self, type, xrange=None, yrange=None, zrange=None):
                     pass
                 def plotData(self):
                     pass
             if __name__ == '__main__':
                 import numpy
                 plplot.plsetopt("geometry", "%dx%d" %(450*2, 200*2))
                 plplot.plsdev("xcairo")
                 plplot.plscolbg(255,255,255)
                 plplot.plscol0(1,0,0,0)
                 plplot.plinit()
                 plplot.plssub(1, 2)
                 nx = 64
                 ny = 100
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 baseObj = RTI()
                 baseObj.setup(1, "Spectrum", "Frequency", "Range", "br_green", False, False)
                 baseObj.plotData(data)
                 data = numpy.random.uniform(-50,50,(nx,ny))
                 base2Obj = RTI()
                 base2Obj.setup(2, "Spectrum", "Frequency", "Range", "br_green", True, True)
                 base2Obj.plotData(data)
                 plplot.plend()
                 exit(0)

schainpy/IO/VoltageIO.py +11 -5

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.Voltage import Voltage
             from IO.DataIO import JRODataReader
             from IO.DataIO import JRODataWriter
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil 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 = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 m_DataObj = None
                 idProfile = 0
                 datablock = None
                 pts2read = 0
                 utc = 0
                 ext = ".r"
                 optchar = "D"
                 def __init__(self, m_Voltage=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         m_Voltage    :    Objeto de la clase Voltage. 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.
                     Variables afectadas:
                         self.m_DataObj
                     Return:
                         None
                     """
                     if m_Voltage == None:
                         m_Voltage = Voltage()
                     if not(isinstance(m_Voltage, Voltage)):
                         raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
                     self.m_DataObj = m_Voltage
                 def __hasNotDataInBuffer(self):
                     if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.pts2read
                         self.blocksize
                     Return:
                         None
                     """
                     self.pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
                     self.blocksize = self.pts2read
                     self.m_DataObj.nProfiles = self.m_ProcessingHeader.profilesPerBlock
                 def readBlock(self):
                     """
                     readBlock 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
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.datablockIndex
                         self.datablock
                         self.flagIsNewFile
                         self.idProfile
                         self.flagIsNewBlock
                         self.nReadBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
                     if self.online:
                         if junk.size != self.blocksize:
                             for nTries in range( self.nTries ):
                                 print "\tWaiting %0.2f sec for the next block, try %03d ..." % (self.delay, nTries+1)
                                 time.sleep( self.delay )
                                 self.fp.seek( fpointer )
                                 fpointer = self.fp.tell()
                                 junk = numpy.fromfile( self.fp, self.dataType, self.pts2read )
                                 if junk.size == self.blocksize:
                                     blockOk_flag = True
                                     break
                             if not( blockOk_flag ):
                                 return 0
                     try:
                         junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
                     except:
                         print "Data file %s is invalid" % self.filename
                         return 0
+                    junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.datablockIndex = 0
                     self.flagIsNewFile = 0
                     self.idProfile = 0
                     self.flagIsNewBlock = 1
                     self.nReadBlocks += 1
                     self.nBlocks += 1
                     return 1
                 def getData(self):
                     """
                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
                     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"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.m_DataObj
                         self.datablockIndex
                         self.idProfile
                     Affected:
                         self.m_DataObj
                         self.datablockIndex
                         self.flagResetProcessing
                         self.flagIsNewBlock
                         self.idProfile
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             self.setNextFile()
                             return 0
                         self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
                         self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                         self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                         self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
                         self.m_DataObj.heights = self.heights
                         self.m_DataObj.dataType = self.dataType
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
                         self.m_DataObj.flagNoData = True
                         return 0
                     time = self.m_BasicHeader.utc + self.datablockIndex * self.ippSeconds
                     self.utc = time
                     #self.m_DataObj.m_BasicHeader.utc = time
                     self.m_DataObj.flagNoData = False
                     self.m_DataObj.flagResetProcessing = self.flagResetProcessing
-                    self.m_DataObj.data = self.datablock[self.datablockIndex,:,:]
+                    self.m_DataObj.data = self.datablock[:,self.datablockIndex,:]
                     self.m_DataObj.idProfile = self.idProfile
                     self.datablockIndex += 1
                     self.idProfile += 1
                     #call setData - to Data Object
                     return 1 #self.m_DataObj.data
             class VoltageWriter( JRODataWriter ):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 __configHeaderFile = 'wrSetHeadet.txt'
                 m_DataObj = None
                 ext = ".r"
                 optchar = "D"
                 datablock = None
                 datablockIndex = 0
                 shapeBuffer = None
                 def __init__(self, m_Voltage=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.m_DataObj
                     Return: None
                     """
                     if m_Voltage == None:
                         m_Voltage = Voltage()
                     if not( isinstance(m_Voltage, Voltage) ):
                         raise ValueError, "in VoltageReader, m_Spectra must be an Spectra class object"
                     self.m_DataObj = m_Voltage
                 def hasAllDataInBuffer(self):
                     if self.datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 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.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
                                         self.m_ProcessingHeader.numHeights,
                                         self.m_SystemHeader.numChannels )
-                    self.datablock = numpy.zeros(self.shapeBuffer, numpy.dtype('complex'))
+                    self.datablock = numpy.zeros(self.m_SystemHeader.numChannels,
+                                                 self.m_ProcessingHeader.profilesPerBlock,
+                                                 self.m_ProcessingHeader.numHeights,
+                                                 numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.datablockIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nWriteBlocks
                         self.blocksCounter
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dataType )
-                    data['real'] = self.datablock.real
+                    junk = numpy.transpose(self.datablock, (1,2,0))
-                    data['imag'] = self.datablock.imag
+                    data['real'] = junk.real
+                    data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.datablockIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nWriteBlocks += 1
                     self.blocksCounter += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.datablockIndex
                     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.m_DataObj.flagNoData:
                         return 0
                     if self.m_DataObj.flagResetProcessing:
                         self.datablock.fill(0)
                         self.datablockIndex = 0
                         self.setNextFile()
-                    self.datablock[self.datablockIndex,:,:] = self.m_DataObj.data
+                    self.datablock[:,self.datablockIndex,:] = self.m_DataObj.data
                     self.datablockIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.getHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
   No newline at end of file

schainpy/Processing/SpectraProcessor.py +19 -16

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Spectra import Spectra
             from IO.SpectraIO import SpectraWriter
             from Graphics.SpectraPlot import Spectrum
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 def __init__(self, spectraInObj, spectraOutObj=None, npts = None):
                     '''
                     Constructor
                     '''
                     self.spectraInObj = spectraInObj
                     if spectraOutObj == None:
                         self.spectraOutObj = Spectra()
                     else:
                         self.spectraOutObj = spectraOutObj
                     self.integratorIndex = None
                     self.decoderIndex = None
                     self.writerIndex = None
                     self.plotterIndex = None
                     if npts != None:
                         self.spectraOutObj.nPoints = npts
                     self.npts = self.spectraOutObj.nPoints
                     self.integratorList = []
                     self.decoderList = []
                     self.writerList = []
                     self.plotterList = []
                     self.buffer = None
                     self.ptsId = 0
                 def init(self):
                     self.integratorIndex = 0
                     self.decoderIndex = 0
                     self.writerIndex = 0
                     self.plotterIndex = 0
                     if not( isinstance(self.spectraInObj, Spectra) ):
                         self.getFft()
                     else:
                         self.spectraOutObj.copy(self.spectraInObj)
                 def getFft(self):
                     if self.buffer == None:
-                        nheis = self.spectraInObj.data.shape[0]
+                        nheis = self.spectraInObj.data.shape[1]
-                        nchannel = self.spectraInObj.data.shape[1]
+                        nchannel = self.spectraInObj.data.shape[0]
                         npoints = self.spectraOutObj.nPoints
-                        self.buffer = numpy.zeros((nchannel,nheis,npoints),dtype='complex')
+                        self.buffer = numpy.zeros((nchannel,npoints,nheis),dtype='complex')
-                    data = numpy.transpose(self.spectraInObj.data)
+                    self.buffer[:,self.ptsId,:] = self.spectraInObj.data
-                    self.buffer[:,:,self.ptsId] = data
                     self.ptsId += 1
                     self.spectraOutObj.flagNoData = True
                     if self.ptsId >= self.spectraOutObj.nPoints:
-                        data_spc = numpy.fft.fft(self.buffer,axis=2)
+                        data_spc = numpy.fft.fft(self.buffer,axis=1)
                         self.ptsId = 0
                         self.buffer = None
                         #calculo de self-spectra
                         self.spectraOutObj.data_spc = numpy.abs(data_spc * numpy.conjugate(data_spc))
                         #calculo de cross-spectra
                         #self.m_Spectra.data_cspc = self.__data_cspc
                         #escribiendo dc
                         #self.m_Spectra.data_dc = self.__data_dc
                         self.spectraOutObj.flagNoData = False
+                    self.spectraOutObj.heights = self.spectraInObj.heights
+                    self.spectraOutObj.m_BasicHeader = self.spectraInObj.m_BasicHeader.copy()
+                    self.spectraOutObj.m_ProcessingHeader = self.spectraInObj.m_ProcessingHeader.copy()
+                    self.spectraOutObj.m_RadarControllerHeader = self.spectraInObj.m_RadarControllerHeader.copy()
+                    self.spectraOutObj.m_SystemHeader = self.spectraInObj.m_SystemHeader.copy()
                 def addWriter(self,wrpath):
                     objWriter = SpectraWriter(self.spectraOutObj)
                     objWriter.setup(wrpath)
                     self.writerList.append(objWriter)
-                def addPlotter(self):
+                def addPlotter(self, index=None):
+                    if index==None:
+                        index = self.plotterIndex
-                    plotObj = Spectrum(self.spectraOutObj,self.plotterIndex)
+                    plotObj = Spectrum(self.spectraOutObj, index)
                     self.plotterList.append(plotObj)
                 def addIntegrator(self,N):
                     objIncohInt = IncoherentIntegration(N)
                     self.integratorList.append(objIncohInt)
                 def writeData(self):
                     if self.voltageOutObj.flagNoData:
                             return 0
                     if len(self.writerList) <= self.writerIndex:
                         self.addWriter(wrpath)
                     self.writerList[self.writerIndex].putData()
                     self.writerIndex += 1
-                def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle=''):
+                def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle='', index=None):
                     if self.spectraOutObj.flagNoData:
                         return 0
                     if len(self.plotterList) <= self.plotterIndex:
-                        self.addPlotter()
+                        self.addPlotter(index)
                     self.plotterList[self.plotterIndex].plotData(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,winTitle=winTitle)
                     self.plotterIndex += 1
                 def integrator(self, N):
                     if self.spectraOutObj.flagNoData:
                             return 0
                     if len(self.integratorList) <= self.integratorIndex:
                         self.addIntegrator(N)
                     myCohIntObj = self.integratorList[self.integratorIndex]
                     myCohIntObj.exe(self.spectraOutObj.data_spc)
                     if myCohIntObj.flag:
                         self.spectraOutObj.data_spc = myCohIntObj.data
                         self.spectraOutObj.m_ProcessingHeader.incoherentInt *= N
                         self.spectraOutObj.flagNoData = False
                     else:
                         self.spectraOutObj.flagNoData = True
                     self.integratorIndex += 1
             class IncoherentIntegration:
                 def __init__(self, N):
                     self.profCounter = 1
                     self.data = None
                     self.buffer = None
                     self.flag = False
                     self.nIncohInt = N
                 def exe(self,data):
                     print 'intg:', self.profCounter
                     if self.buffer == None:
                         self.buffer = data
                     else:
                         self.buffer = self.buffer + data
                     if self.profCounter == self.nIncohInt:
                         self.data = self.buffer
                         self.buffer = None
                         self.profCounter = 0
                         self.flag = True
                     else:
                         self.flag = False
                     self.profCounter += 1

schainpy/Processing/VoltageProcessor.py +5 -5

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Voltage import Voltage
             from IO.VoltageIO import VoltageWriter
             from Graphics.VoltagePlot import Osciloscope
             class VoltageProcessor:
                 '''
                 classdocs
                 '''
                 def __init__(self, voltageInObj, voltageOutObj=None):
                     '''
                     Constructor
                     '''
                     self.voltageInObj = voltageInObj
                     if voltageOutObj == None:
                         self.voltageOutObj = Voltage()
                     else:
                         self.voltageOutObj = voltageOutObj
                     self.integratorIndex = None
                     self.decoderIndex = None
                     self.writerIndex = None
                     self.plotterIndex = None
                     self.integratorList = []
                     self.decoderList = []
                     self.writerList = []
                     self.plotterList = []
                 def init(self):
                     self.integratorIndex = 0
                     self.decoderIndex = 0
                     self.writerIndex = 0
                     self.plotterIndex = 0
                     self.voltageOutObj.copy(self.voltageInObj)
                 def addWriter(self,wrpath):
                     objWriter = VoltageWriter(self.voltageOutObj)
                     objWriter.setup(wrpath)
                     self.writerList.append(objWriter)
                 def addPlotter(self):
                     plotObj = Osciloscope(self.voltageOutObj,self.plotterIndex)
                     self.plotterList.append(plotObj)
                 def addIntegrator(self,N):
                     objCohInt = CoherentIntegrator(N)
                     self.integratorList.append(objCohInt)
                 def addDecoder(self,code,ncode,nbaud):
                     objDecoder = Decoder(code,ncode,nbaud)
                     self.decoderList.append(objDecoder)
                 def writeData(self,wrpath):
                     if self.voltageOutObj.flagNoData:
                             return 0
                     if len(self.writerList) <= self.writerIndex:
                         self.addWriter(wrpath)
                     self.writerList[self.writerIndex].putData()
             #        myWrObj = self.writerList[self.writerIndex]
             #        myWrObj.putData()
                     self.writerIndex += 1
                 def plotData(self,idProfile, type, xmin=None, xmax=None, ymin=None, ymax=None, winTitle=''):
                     if self.voltageOutObj.flagNoData:
                             return 0
                     if len(self.plotterList) <= self.plotterIndex:
                         self.addPlotter()
                     self.plotterList[self.plotterIndex].plotData(type=type, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,winTitle=winTitle)
                     self.plotterIndex += 1
                 def integrator(self, N):
                     if self.voltageOutObj.flagNoData:
                             return 0
                     if len(self.integratorList) <= self.integratorIndex:
                         self.addIntegrator(N)
                     myCohIntObj = self.integratorList[self.integratorIndex]
                     myCohIntObj.exe(self.voltageOutObj.data)
                     if myCohIntObj.flag:
                         self.voltageOutObj.data = myCohIntObj.data
                         self.voltageOutObj.m_ProcessingHeader.coherentInt *= N
                         self.voltageOutObj.flagNoData = False
                     else:
                         self.voltageOutObj.flagNoData = True
                     self.integratorIndex += 1
                 def decoder(self,code=None,type = 0):
                     if self.voltageOutObj.flagNoData:
                             return 0
                     if code == None:
                         code = self.voltageOutObj.m_RadarControllerHeader.code
                     ncode, nbaud = code.shape
                     if len(self.decoderList) <= self.decoderIndex:
                         self.addDecoder(code,ncode,nbaud)
                     myDecodObj = self.decoderList[self.decoderIndex]
                     myDecodObj.exe(data=self.voltageOutObj.data,type=type)
                     if myDecodObj.flag:
                         self.voltageOutObj.data = myDecodObj.data
                         self.voltageOutObj.flagNoData = False
                     else:
                         self.voltageOutObj.flagNoData = True
                     self.decoderIndex += 1
                 def removeDC(self):
                     pass
                 def removeSignalInt(self):
                     pass
                 def selChannel(self):
                     pass
                 def selRange(self):
                     pass
                 def selProfiles(self):
                     pass
             class Decoder:
                 def __init__(self,code, ncode, nbaud):
                     self.buffer = None
                     self.profCounter = 1
                     self.nCode = ncode
                     self.nBaud = nbaud
                     self.codeIndex = 0
                     self.code = code #this is a List
                     self.fft_code = None
                     self.flag = False
                     self.setCodeFft = False
                 def exe(self, data, ndata=None, type = 0):
-                    if ndata == None: ndata = data.shape[0]
+                    if ndata == None: ndata = data.shape[1]
                     if type == 0:
                         self.convolutionInFreq(data,ndata)
                     if type == 1:
                         self.convolutionInTime(data, ndata)
                 def convolutionInFreq(self,data,ndata):
                     newcode = numpy.zeros(ndata)
                     newcode[0:self.nBaud] = self.code[self.codeIndex]
                     self.codeIndex += 1
-                    fft_data = numpy.fft.fft(data, axis=0)
+                    fft_data = numpy.fft.fft(data, axis=1)
                     fft_code = numpy.conj(numpy.fft.fft(newcode))
-                    fft_code = fft_code.reshape(len(fft_code),1)
+                    fft_code = fft_code.reshape(1,len(fft_code))
                     conv = fft_data.copy()
                     conv.fill(0)
                     conv = fft_data*fft_code    #            This other way to calculate multiplication between bidimensional arrays
                                                                 #            for i in range(ndata):
                                                                 #                conv[i,:] = fft_data[i,:]*fft_code[i]
-                    self.data = numpy.fft.ifft(conv,axis=0)
+                    self.data = numpy.fft.ifft(conv,axis=1)
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
                 def convolutionInTime(self, data, ndata):
                     nchannel = data.shape[1]
                     newcode = self.code[self.codeIndex]
                     self.codeIndex += 1
                     conv = data.copy()
                     for i in range(nchannel):
-                        conv[:,i] = numpy.correlate(data[:,i], newcode, 'same')
+                        conv[i,:] = numpy.correlate(data[i,:], newcode, 'same')
                     self.data = conv
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
             class CoherentIntegrator:
                 def __init__(self, N):
                     self.profCounter = 1
                     self.data = None
                     self.buffer = None
                     self.flag = False
                     self.nCohInt = N
                 def exe(self,data):
                     if self.buffer == None:
                         self.buffer = data
                     else:
                         self.buffer = self.buffer + data
                     if self.profCounter == self.nCohInt:
                         self.data = self.buffer
                         self.buffer = None
                         self.profCounter = 0
                         self.flag = True
                     else:
                         self.flag = False
                     self.profCounter += 1
   No newline at end of file

schainpy/TestDataSChain.py +5 -3

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import time, datetime
             from Model.JROData import JROData
             from IO.DataIO import *
             #===============================================================================
             # from Graphics.DataPlot import Osciloscope
             #
             # from Model.Spectra import Spectra
             # from IO.SpectraIO import *
             # from Graphics.SpectraPlot import Spectrum
             #===============================================================================
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                     pass
                 def setValues(self):
-                    self.path = "/home/valentin/Tmp/RAWDATA"
+                    #self.path = "/home/valentin/Tmp/RAWDATA"
-                    self.startDateTime = datetime.datetime(2009,11,2,00,00,0)
+                    self.path = "/home/dsuarez/Projects"
-                    self.endDateTime = datetime.datetime(2009,11,30,18,10,0)
+                    #self.wrpath = "/home/dsuarez/Projects/testWR"
+                    self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
+                    self.endDateTime = datetime.datetime(2007,5,1,16,0,0)
                 def createObjects(self):
                     self.Obj = JROData()
                     self.readerObj = JRODataReader(self.Obj)
                     #self.plotObj = Spectrum(self.Obj)
                     if not(self.readerObj.setup(self.path, self.startDateTime, self.endDateTime, ext = '.pdata', expLabel='', online =1)):
                         sys.exit(0)
                 def testSChain(self):
                     ini = time.time()
                     while(True):
                         if self.readerObj.getData():
                             print "",
                             #self.plotObj.plotData(zmin=40, zmax=140, showColorbar=True, showPowerProfile=True)
             #            self.writerObj.putData()
                         if self.readerObj.noMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock and self.readerObj.nReadBlocks:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
                                                               datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
                             #===============================================================
                             # fin = time.time()
                             # print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
                             # ini = time.time()
                             #===============================================================
                         #time.sleep(0.5)
                     self.plotObj.end()
             if __name__ == '__main__':
                 TestSChain()

schainpy/TestSVoltageChain.py +54 -11

             '''
             Created on 27/03/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import time, datetime
             from Model.Voltage import Voltage
             from IO.VoltageIO import *
-            from Graphics.VoltagePlot import Osciloscope
+            #from Graphics.VoltagePlot import Osciloscope
+            from Model.Spectra import Spectra
+            from IO.SpectraIO import *
+            from Processing.VoltageProcessor import *
+            from Processing.SpectraProcessor import *
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
-                    pass
                 def setValues( self ):
-                    self.path = "/home/valentin/Tmp/VOLTAGE"  #1
+                    self.path = "/home/dsuarez/Projects"  #1
                     #self.path = "/home/valentin/Tmp/VOLTAGE2" #2
-                    self.startDateTime = datetime.datetime(2011,10,4,00,00,0)
+            #        self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
-                    self.endDateTime = datetime.datetime(2011,10,31,23,59,59)
+            #        self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
+                    self.startDateTime = datetime.datetime(2011,10,4,0,0,0)
+                    self.endDateTime = datetime.datetime(2011,10,4,0,20,0)
+                    self.N = 2
+                    self.npts = 4
                 def createObjects( self ):
                     self.Obj = Voltage()
+                    self.OutObj = Voltage()
                     self.readerObj = VoltageReader(self.Obj)
-                    self.plotObj = Osciloscope(self.Obj)
+                    self.procObj = VoltageProcessor(self.Obj, self.OutObj)
+                    self.spectraObj = Spectra()
+                    self.specProcObj = SpectraProcessor(self.OutObj, self.spectraObj,self.npts)
+                    #self.plotObj = Osciloscope(self.Obj)
                     if not(self.readerObj.setup( self.path, self.startDateTime, self.endDateTime, expLabel='', online =0) ):
                         sys.exit(0)
+            #        if not(self.readerObj.setup(self.path, self.startDateTime, self.endDateTime)):
+            #            sys.exit(0)
                 def testSChain( self ):
                     ini = time.time()
                     while(True):
-                        if self.readerObj.getData():
+                        self.readerObj.getData()
-                            self.plotObj.plotData(idProfile=0, type='power' )
-                        if self.readerObj.flagNoMoreFiles:
+                        self.procObj.init()
-                            break
+                        self.procObj.plotData(idProfile = 1, type='power',winTitle='figura 1')
+                        self.procObj.decoder(type=0)
+            #            self.procObj.plotData(idProfile = 1, type='iq', xmin=0, xmax=100,winTitle='figura 2')
+            #
+            #            self.procObj.integrator(self.N)
+                        self.procObj.plotData(idProfile = 1, type='power',winTitle='figura 3')
+                        self.specProcObj.init()
+                        self.specProcObj.integrator(2)
+                        self.specProcObj.plotData(winTitle='Spectra 1', index=2)
+            #            if self.readerObj.getData():
+            #                self.plotObj.plotData(idProfile=0, type='power' )
+            #
+            #
+            #            if self.readerObj.flagNoMoreFiles:
+            #                break
+            #
                         if self.readerObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nReadBlocks,
                                                               datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
             #                fin = time.time()
             #                print 'Tiempo de un bloque leido y escrito: [%6.5f]' %(fin - ini)
             #                ini = time.time()
                         #time.sleep(0.5)
-                    self.plotObj.end()
+            #        self.plotObj.end()
             if __name__ == '__main__':
                 TestSChain()

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