schain Commit - r227:3959fdcb8502 · Jicamarca Repository

Bugs fixed: Eliminacion de numpy.abs() en el calculo de las cross-correlaciones y mejoras en los graficos de CrossSpectra

Miguel Valdez -

r227:3959fdcb8502

parent child

Context file:

r227:3959fdcb8502

Collapse all files

schainpy/model/graphics/mpldriver.py +3 -86

             import numpy
             import datetime
             import matplotlib
             matplotlib.use("TKAgg")
             import matplotlib.pyplot
             import matplotlib.dates
             #import scitools.numpyutils
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.dates import DayLocator, HourLocator, MinuteLocator, SecondLocator, DateFormatter
             from matplotlib.ticker import FuncFormatter
             from matplotlib.ticker import *
-            #def init(idfigure, wintitle, width, height, facecolor="w"):
-            #    matplotlib.pyplot.ioff()
-            #    fig = matplotlib.pyplot.matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
-            #    fig.canvas.manager.set_window_title(wintitle)
-            #    fig.canvas.manager.resize(width, height)
-            #    matplotlib.pyplot.ion()
-            #    return fig
-            #def setWinTitle(fig, title):
-            #    fig.canvas.manager.set_window_title(title)
-            #def setTitle(idfigure, title):
-            #    fig = matplotlib.pyplot.figure(idfigure)
-            #    fig.suptitle(title)
-            #def makeAxes(idfigure, nrow, ncol, xpos, ypos, colspan, rowspan):
-            #    fig = matplotlib.pyplot.figure(idfigure)
-            #    ax = matplotlib.pyplot.subplot2grid((nrow, ncol), (xpos, ypos), colspan=colspan, rowspan=rowspan)
-            #    return ax
-            #def setTextFromAxes(idfigure, ax, title):
-            #    fig = matplotlib.pyplot.figure(idfigure)
-            #    ax.annotate(title, xy=(.1, .99),
-            #                xycoords='figure fraction',
-            #                horizontalalignment='left', verticalalignment='top',
-            #                fontsize=10)
-            #def pline(ax, x, y, xmin, xmax, ymin, ymax, xlabel, ylabel, title, firsttime):
-            #    if firsttime:
-            #        ax.plot(x, y)
-            #        ax.set_xlim([xmin,xmax])
-            #        ax.set_ylim([ymin,ymax])
-            #        ax.set_xlabel(xlabel, size=8)
-            #        ax.set_ylabel(ylabel, size=8)
-            #        ax.set_title(title, size=10)
-            #        matplotlib.pyplot.tight_layout()
-            #    else:
-            #        ax.lines[0].set_data(x,y)
-            #def draw(idfigure):
-            #    fig = matplotlib.pyplot.figure(idfigure)
-            #    fig.canvas.draw()
-            #def pcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax, xlabel, ylabel, title, firsttime, mesh):
-            #    if firsttime:
-            #        divider = make_axes_locatable(ax)
-            #        ax_cb = divider.new_horizontal(size="4%", pad=0.05)
-            #        fig1 = ax.get_figure()
-            #        fig1.add_axes(ax_cb)
-            #        ax.set_xlim([xmin,xmax])
-            #        ax.set_ylim([ymin,ymax])
-            #        ax.set_xlabel(xlabel)
-            #        ax.set_ylabel(ylabel)
-            #        ax.set_title(title)
-            #        print x
-            #        imesh=ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
-            #        matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
-            #        ax_cb.yaxis.tick_right()
-            #        for tl in ax_cb.get_yticklabels():
-            #            tl.set_visible(True)
-            #        ax_cb.yaxis.tick_right()
-            #        matplotlib.pyplot.tight_layout()
-            #        return imesh
-            #    else:
-            ##        ax.set_xlim([xmin,xmax])
-            ##        ax.set_ylim([ymin,ymax])
-            #        ax.set_xlabel(xlabel)
-            #        ax.set_ylabel(ylabel)
-            #        ax.set_title(title)
-            #        z = z.T
-            ##        z = z[0:-1,0:-1]
-            #        mesh.set_array(z.ravel())
-            #        return mesh
             ###########################################
             #Actualizacion de las funciones del driver
             ###########################################
             def createFigure(idfigure, wintitle, width, height, facecolor="w"):
                 matplotlib.pyplot.ioff()
-                fig = matplotlib.pyplot.matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
+                fig = matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 return fig
             def closeFigure():
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.show()
                 return
             def saveFigure(fig, filename):
                 fig.savefig(filename)
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(fig, title):
                 fig.suptitle(title)
             def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan):
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                     (xpos, ypos),
                                                     colspan=colspan,
                                                     rowspan=rowspan)
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             xy = (.1, .99),
                             xycoords = 'figure fraction',
                             horizontalalignment = 'left',
                             verticalalignment = 'top',
                             fontsize = 10)
             def printLabels(ax, xlabel, ylabel, title):
                 ax.set_xlabel(xlabel, size=11)
                 ax.set_ylabel(ylabel, size=11)
                 ax.set_title(title, size=12)
             def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 ax.plot(x, y)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
                 xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/nxticks) + int(xmin)
                 ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 ######################################################
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 return iplot
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 iplot.set_data(x, y)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize = 9,
-                             cblabel='', cbsize="5%",
+                             colormap='jet',cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 divider = make_axes_locatable(ax)
                 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
                 fig = ax.get_figure()
                 fig.add_axes(ax_cb)
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
-                imesh = ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
+                imesh = ax.pcolormesh(x,y,z.T, vmin=zmin, vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
                 cb =  matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                 cb.set_label(cblabel)
             #    for tl in ax_cb.get_yticklabels():
             #        tl.set_visible(True)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in cb.ax.get_yticklabels():
                     tick.set_fontsize(ticksize)
                 ax_cb.yaxis.tick_right()
                 if '0.' in matplotlib.__version__[0:2]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print "The matplotlib version has to be updated to 1.1 or newer"
                     return imesh
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 return imesh
             def pcolor(imesh, z, xlabel='', ylabel='', title=''):
                 z = z.T
                 ax = imesh.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 imesh.set_array(z.ravel())
             def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title=''):
                 printLabels(ax, xlabel, ylabel, title)
                 imesh = ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax)
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError, "This parameter should be of tpye matplotlib figure"
                 fig.canvas.draw()

schainpy/model/jrodata.py +4 -4

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import os, sys
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of de noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
                 dataflat = data.copy().reshape(-1)
                 dataflat.sort()
                 npts = dataflat.size #numbers of points of the data
                 npts_noise = 0.2*npts
                 if npts < 32:
                     print "error in noise - requires at least 32 points"
                     return -1.0
                 dataflat2 = numpy.power(dataflat,2)
                 cs = numpy.cumsum(dataflat)
                 cs2 = numpy.cumsum(dataflat2)
                 # data sorted in ascending order
                 nmin = int((npts + 7.)/8)
                 for i in range(nmin, npts):
                     s = cs[i]
                     s2 = cs2[i]
                     p  = s / float(i);
                     p2 = p**2;
                     q  = s2 / float(i) - p2;
                     leftc = p2;
                     rightc = q * float(navg);
                     R2 = leftc/rightc
                     # Signal detect: R2 < 1 (R2 = leftc/rightc)
                     if R2 < 1:
                         npts_noise = i
                         break
                 anoise = numpy.average(dataflat[0:npts_noise])
                 return anoise;
             def sorting_bruce(data, navg):
                 data = data.copy()
                 sortdata = numpy.sort(data)
                 lenOfData = len(data)
                 nums_min = lenOfData/10
                 if (lenOfData/10) > 0:
                     nums_min = lenOfData/10
                 else:
                     nums_min = 0
                 rtest = 1.0 + 1.0/navg
                 sum = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont==1)and(j<lenOfData)):
                     sum += sortdata[j]
                     sumq += sortdata[j]**2
                     j += 1
                     if j > nums_min:
                         if ((sumq*j) <= (rtest*sum**2)):
                             lnoise = sum / j
                         else:
                             j = j - 1
                             sum  = sum - sordata[j]
                             sumq =  sumq - sordata[j]**2
                             cont = 0
                     if j == nums_min:
                         lnoise = sum /j
                 return lnoise
             class JROData:
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagTimeBlock = False
                 utctime = None
                 blocksize = None
                 nCode = None
                 nBaud = None
                 code = None
                 flagDecodeData = True #asumo q la data esta decodificada
                 flagDeflipData = True #asumo q la data esta sin flip
                 flagShiftFFT = False
                 ippSeconds = None
                 timeInterval = None
                 nCohInt = None
                 noise = None
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
                 def getNoise(self):
                     raise ValueError, "Not implemented"
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.utctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.utctime)
                     datatime.append(self.utctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF/2.
                     return fmax
                 def getVmax(self):
                     _lambda = self.C/self.frequency
-                    vmax = self.getFmax() * _lambda / 2.
+                    vmax = self.getFmax() * _lambda
                     return vmax
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.blocksize = None
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,:,:]
                         self.noise[channel] = hildebrand_sekhon(daux, self.nCohInt)
                     return self.noise
                 def getNoise(self, type = 1):
                     self.noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     return 10*numpy.log10(noise)
             class Spectra(JROData):
                 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                 def getNoisebyHildebrand(self):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,:,:]
                         self.noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return self.noise
                 def getNoisebyWindow(self, heiIndexMin=0, heiIndexMax=-1, freqIndexMin=0, freqIndexMax=-1):
                     """
                     Determina el ruido del canal utilizando la ventana indicada con las coordenadas:
                     (heiIndexMIn, freqIndexMin) hasta (heiIndexMax, freqIndexMAx)
                     Inputs:
                         heiIndexMin: Limite inferior del eje de alturas
                         heiIndexMax: Limite superior del eje de alturas
                         freqIndexMin: Limite inferior del eje de frecuencia
                         freqIndexMax: Limite supoerior del eje de frecuencia
                     """
                     data = self.data_spc[:, heiIndexMin:heiIndexMax, freqIndexMin:freqIndexMax]
                     for channel in range(self.nChannels):
                         daux = data[channel,:,:]
                         self.noise[channel] = numpy.average(daux)
                     return self.noise
                 def getNoisebySort(self):
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,:,:]
                         self.noise[channel] = sorting_bruce(daux, self.nIncohInt)
                     return self.noise
                 def getNoise(self, type = 1):
                     self.noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return 10*numpy.log10(noise)
                 def getFreqRange(self, extrapoints=0):
-                    delfreq = 2 * self.getFmax() / self.nFFTPoints
+                    deltafreq = self.getFmax() / self.nFFTPoints
-                    freqrange = deltafreqs*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
+                    freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
-                    deltav = 2 * self.getVmax() / self.nFFTPoints
+                    deltav = self.getVmax() / self.nFFTPoints
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 nPairs = property(getNPairs, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, "I'm the 'pairsIndexList' property.")
             class SpectraHeis(JROData):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
                 nPairs = None
                 pairsList = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagTimeBlock = False
                     self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None

schainpy/model/jroplot.py +4 -4

             import numpy
             import time, datetime
             from graphics.figure import  *
             class CrossSpectraPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 4
                     self.WIDTH = 300
                     self.HEIGHT = 400
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = 4
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
-                    if pairIndexList == []:
+                    if pairsIndexList == []:
                         return
-                    x = dataOut.getVelRange(1)
+                    x = dataOut.getFreqRange(1)
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[:,:,:])
                     avg = numpy.average(numpy.abs(z), axis=1)
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
                         self.__isConfig = True
                     thisDatetime = dataOut.datatime
                     title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         title = "Channel %d: %4.2fdB" %(pair[0], noise[pair[0]])
                         z = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:])
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, z,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                         title = "Channel %d: %4.2fdB" %(pair[1], noise[pair[1]])
                         z = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:])
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, z,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
                         coherence = numpy.abs(coherenceComplex)
                         phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         title = "Coherence %d%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+2]
                         axes0.pcolor(x, y, coherence,
-                                    xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-1, zmax=1,
+                                    xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                         title = "Phase %d%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+3]
                         axes0.pcolor(x, y, phase,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
-                                    ticksize=9, cblabel='')
+                                    ticksize=9, cblabel='', colormap='RdBu')
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d")
                         if figfile == None:
                             figfile = self.getFilename(name = date)
                         self.saveFigure(figpath, figfile)
             class RTIPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self):
                     self.__timerange = 24*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def __getTimeLim(self, x, xmin, xmax):
                     thisdatetime = datetime.datetime.utcfromtimestamp(numpy.min(x))
                     thisdate = datetime.datetime.combine(thisdatetime.date(), datetime.time(0,0,0))
                     ####################################################
                     #If the x is out of xrange
                     if xmax < (thisdatetime - thisdate).seconds/(60*60.):
                         xmin = None
                         xmax = None
                     if xmin == None:
                         td = thisdatetime - thisdate
                         xmin = td.seconds/(60*60.)
                     if xmax == None:
                         xmax = xmin + self.__timerange/(60*60.)
                     mindt = thisdate + datetime.timedelta(0,0,0,0,0, xmin)
                     tmin = time.mktime(mindt.timetuple())
                     maxdt = thisdate + datetime.timedelta(0,0,0,0,0, xmax)
                     tmax = time.mktime(maxdt.timetuple())
                     self.__timerange = tmax - tmin
                     return tmin, tmax
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if timerange != None:
                         self.__timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         tmin, tmax = self.__getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
                         self.__isConfig = True
                     thisDatetime = dataOut.datatime
                     title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         title = "Channel %d: %s" %(dataOut.channelList[i], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z = avg[i].reshape((1,-1))
                         axes.pcolor(x, y, z,
                                     xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%")
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avg[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d")
                         if figfile == None:
                             figfile = self.getFilename(name = date)
                         self.saveFigure(figpath, figfile)
                     if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
                         self.__isConfig = False
             class SpectraPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 300
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = 10.*numpy.log10(dataOut.data_spc[channelIndexList,:,:])
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avg)*0.9
                         if zmax == None: zmax = numpy.nanmax(avg)*0.9
                         self.__isConfig = True
                     thisDatetime = dataOut.datatime
                     title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noise[i])
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, z[i,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avg[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d")
                         if figfile == None:
                             figfile = self.getFilename(name = date)
                         self.saveFigure(figpath, figfile)
             class Scope(Figure):
                 __isConfig = None
                 def __init__(self):
                     self.__isConfig = False
                     self.WIDTH = 600
                     self.HEIGHT = 200
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle):
                     self.createFigure(idfigure, wintitle)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                     self.nplots = nplots
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False, filename=None):
                     """
                     Input:
                         dataOut         :
                         idfigure        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError, "Channel %d is not in dataOut.channelList"
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.heightList
                     y = dataOut.data[channelList,:] * numpy.conjugate(dataOut.data[channelList,:])
                     y = y.real
                     noise = dataOut.getNoise()
                     if not self.__isConfig:
                         nplots = len(channelList)
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         self.__isConfig = True
                     thisDatetime = dataOut.datatime
                     title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d: %4.2fdB" %(i, noise[i])
                         axes = self.axesList[i]
                         ychannel = y[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                     self.draw()
                     if save:
                         self.saveFigure(filename)
   No newline at end of file

schainpy/model/jroprocessing.py +2 -2

             '''
             $Author: dsuarez $
             $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
             '''
             import os
             import numpy
             import datetime
             import time
             from jrodata import *
             from jrodataIO import *
             from jroplot import *
             class ProcessingUnit:
                 """
                 Esta es la clase base para el procesamiento de datos.
                 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                     - Metodos internos (callMethod)
                     - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                       tienen que ser agreagados con el metodo "add".
                 """
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataIn = None
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataOut = None
                 objectDict = None
                 def __init__(self):
                     self.objectDict = {}
                 def init(self):
                     raise ValueError, "Not implemented"
                 def addOperation(self, object, objId):
                     """
                     Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
                     identificador asociado a este objeto.
                     Input:
                         object    :    objeto de la clase "Operation"
                     Return:
                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
                     self.objectDict[objId] = object
                     return objId
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     raise ValueError, "ImplementedError"
                 def callMethod(self, name, **kwargs):
                     """
                     Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                     Input:
                         name        :    nombre del metodo a ejecutar
                         **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                     """
                     if name != 'run':
                         if name == 'init' and self.dataIn.isEmpty():
                             self.dataOut.flagNoData = True
                             return False
                         if name != 'init' and self.dataOut.isEmpty():
                             return False
                     methodToCall = getattr(self, name)
                     methodToCall(**kwargs)
                     if name != 'run':
                         return True
                     if self.dataOut.isEmpty():
                         return False
                     return True
                 def callObject(self, objId, **kwargs):
                     """
                     Ejecuta la operacion asociada al identificador del objeto "objId"
                     Input:
                         objId        :    identificador del objeto a ejecutar
                         **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                     Return:
                         None
                     """
                     if self.dataOut.isEmpty():
                         return False
                     object = self.objectDict[objId]
                     object.run(self.dataOut, **kwargs)
                     return True
                 def call(self, operationConf, **kwargs):
                     """
                     Return True si ejecuta la operacion "operationConf.name" con los
                     argumentos "**kwargs". False si la operacion no se ha ejecutado.
                     La operacion puede ser de dos tipos:
 . Un metodo propio de esta clase:
                             operation.type = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                             operation.type = "other".
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el operation.id
                     con el id de la operacion.
                     Input:
                         Operation    :    Objeto del tipo operacion con los atributos: name, type y id.
                     """
                     if operationConf.type == 'self':
                         sts = self.callMethod(operationConf.name, **kwargs)
                     if operationConf.type == 'other':
                         sts = self.callObject(operationConf.id, **kwargs)
                     return sts
                 def setInput(self, dataIn):
                     self.dataIn = dataIn
                 def getOutput(self):
                     return self.dataOut
             class Operation():
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                 y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
                 Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 __buffer = None
                 __isConfig = False
                 def __init__(self):
                     pass
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     raise ValueError, "ImplementedError"
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     self.objectDict = {}
                     self.dataOut = Voltage()
                 def init(self):
                     self.dataOut.copy(self.dataIn)
                     # No necesita copiar en cada init() los atributos de dataIn
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             print channelIndexList
                             raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
                     nChannels = len(channelIndexList)
                     data = self.dataOut.data[channelIndexList,:]
                     self.dataOut.data = data
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
                     return 1
                 def selectHeights(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
             #            raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOut.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
             #            raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nHeights = maxIndex - minIndex + 1
                     #voltage
                     data = self.dataOut.data[:,minIndex:maxIndex+1]
                     firstHeight = self.dataOut.heightList[minIndex]
                     self.dataOut.data = data
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                     return 1
                 def filterByHeights(self, window):
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     if window == None:
                         window = self.dataOut.radarControllerHeaderObj.txA / deltaHeight
                     newdelta = deltaHeight * window
                     r = self.dataOut.data.shape[1] % window
                     buffer = self.dataOut.data[:,0:self.dataOut.data.shape[1]-r]
                     buffer = buffer.reshape(self.dataOut.data.shape[0],self.dataOut.data.shape[1]/window,window)
                     buffer = numpy.sum(buffer,2)
                     self.dataOut.data = buffer
                     self.dataOut.heightList = numpy.arange(self.dataOut.heightList[0],newdelta*self.dataOut.nHeights/window,newdelta)
             class CohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 n = None
                 def __init__(self):
                     self.__isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if n == None and timeInterval == None:
                         raise ValueError, "n or timeInterval should be specified ..."
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer == None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata == None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if not self.__isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.__isConfig = True
                     avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
             #        dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         dataOut.nCohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                         dataOut.flagNoData = False
             class SpectraProc(ProcessingUnit):
                 def __init__(self):
                     self.objectDict = {}
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                 def __updateObjFromInput(self):
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = self.dataIn.dtype
             #        self.dataOut.nHeights = self.dataIn.nHeights
             #        self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
             #        self.dataOut.channelIndexList = self.dataIn.channelIndexList
                     self.dataOut.flagTimeBlock = self.dataIn.flagTimeBlock
                     self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nFFTPoints*self.dataOut.nIncohInt
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                     """
-                    fft_volt = numpy.fft.fft(self.buffer,axis=1)
+                    fft_volt = numpy.fft.fft(self.buffer,axis=1)/numpy.sqrt(self.dataOut.nFFTPoints)
                     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.dataOut.pairsList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
-                            cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
+                            cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc = spc
                     self.dataOut.data_cspc = cspc
                     self.dataOut.data_dc = dc
                     self.dataOut.blockSize = blocksize
                 def init(self, nFFTPoints=None, pairsList=None):
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         return
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProc.init() need nFFTPoints input variable"
                         if pairsList == None:
                             nPairs = 0
                         else:
                             nPairs = len(pairsList)
                         self.dataOut.nFFTPoints = nFFTPoints
                         self.dataOut.pairsList = pairsList
                         self.dataOut.nPairs = nPairs
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                        self.dataOut.nFFTPoints,
                                                        self.dataIn.nHeights),
                                                        dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataIn.data
                         self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == self.dataOut.nFFTPoints:
                             self.__updateObjFromInput()
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.buffer = None
                             self.firstdatatime = None
                             self.profIndex = 0
                         return
                     raise ValuError, "The type object %s is not valid"%(self.dataIn.type)
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             print channelIndexList
                             raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
                     nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
                     return 1
             class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer_spc = None
                 __buffer_cspc = None
                 __buffer_dc = None
                 __dataReady = False
                 n = None
                 def __init__(self):
                     self.__isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer_spc = None
                     self.__buffer_cspc = None
                     self.__buffer_dc = None
                     self.__dataReady = False
                     if n == None and timeInterval == None:
                         raise ValueError, "n or timeInterval should be specified ..."
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                     else:
                         self.__withOverapping = False
                         self.__buffer_spc = 0
                         self.__buffer_cspc = 0
                         self.__buffer_dc = 0
                     self.__profIndex = 0
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer_spc += data_spc
                         if data_cspc == None:
                             self.__buffer_cspc = None
                         else:
                             self.__buffer_cspc += data_cspc
                         if data_dc == None:
                             self.__buffer_dc = None
                         else:
                             self.__buffer_dc += data_dc
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nFFTPoints, nHeis = data_spc.shape
                     data_spc = numpy.reshape(data_spc, (1, nChannels, nFFTPoints, nHeis))
                     if data_cspc != None:
                         data_cspc = numpy.reshape(data_cspc, (1, -1, nFFTPoints, nHeis))
                     if data_dc != None:
                         data_dc = numpy.reshape(data_dc, (1, -1, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer_spc == None:
                         self.__buffer_spc = data_spc
                         if data_cspc == None:
                             self.__buffer_cspc = None
                         else:
                             self.__buffer_cspc += data_cspc
                         if data_dc == None:
                             self.__buffer_dc = None
                         else:
                             self.__buffer_dc += data_dc
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer_spc = numpy.vstack((self.__buffer_spc, data_spc))
                         if data_cspc != None:
                             self.__buffer_cspc = numpy.vstack((self.__buffer_cspc, data_cspc))
                         if data_dc != None:
                             self.__buffer_dc = numpy.vstack((self.__buffer_dc, data_dc))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer_spc = numpy.roll(self.__buffer_spc, -1, axis=0)
                     self.__buffer_spc[self.n-1] = data_spc
                     if data_cspc != None:
                         self.__buffer_cspc = numpy.roll(self.__buffer_cspc, -1, axis=0)
                         self.__buffer_cspc[self.n-1] = data_cspc
                     if data_dc != None:
                         self.__buffer_dc = numpy.roll(self.__buffer_dc, -1, axis=0)
                         self.__buffer_dc[self.n-1] = data_dc
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     data_spc = None
                     data_cspc  = None
                     data_dc = None
                     if not self.__withOverapping:
                         data_spc = self.__buffer_spc
                         data_cspc = self.__buffer_cspc
                         data_dc = self.__buffer_dc
                         n = self.__profIndex
                         self.__buffer_spc = 0
                         self.__buffer_cspc = 0
                         self.__buffer_dc = 0
                         self.__profIndex = 0
                         return data_spc, data_cspc, data_dc, n
                     #Integration with Overlapping
                     data_spc = numpy.sum(self.__buffer_spc, axis=0)
                     if self.__buffer_cspc != None:
                         data_cspc = numpy.sum(self.__buffer_cspc, axis=0)
                     if self.__buffer_dc != None:
                         data_dc = numpy.sum(self.__buffer_dc, axis=0)
                     n = self.__profIndex
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     n = None
                     self.putData(*args)
                     if self.__profIndex == self.n:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def byTime(self, datatime, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     n = None
                     self.putData(*args)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def integrate(self, datatime, *args):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                     self.__lastdatatime = datatime
                     if avgdata_spc == None:
                         return None, None, None, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if not self.__isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.__isConfig = True
                     avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                         dataOut.data_spc,
                                                                                         dataOut.data_cspc,
                                                                                         dataOut.data_dc)
             #        dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt * dataOut.nIncohInt * dataOut.nFFTPoints
                         dataOut.flagNoData = False
             class ProfileSelector(Operation):
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self):
                     self.profileIndex = 0
                 def incIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isProfileInRange(self, minIndex, maxIndex):
                     if self.profileIndex < minIndex:
                         return False
                     if self.profileIndex > maxIndex:
                         return False
                     return True
                 def isProfileInList(self, profileList):
                     if self.profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut, profileList=None, profileRangeList=None):
                     self.nProfiles = dataOut.nProfiles
                     if profileList != None:
                         if not(self.isProfileInList(profileList)):
                             dataOut.flagNoData = True
                         else:
                             dataOut.flagNoData = False
                         self.incIndex()
                         return 1
                     elif profileRangeList != None:
                         minIndex = profileRangeList[0]
                         maxIndex = profileRangeList[1]
                         if not(self.isProfileInRange(minIndex, maxIndex)):
                             dataOut.flagNoData = True
                         else:
                             dataOut.flagNoData = False
                         self.incIndex()
                         return 1
                     else:
                         raise ValueError, "ProfileSelector needs profileList or profileRangeList"
                     return 0
             class Decoder:
                 data = None
                 profCounter = None
                 code = None
                 ncode = None
                 nbaud = None
                 codeIndex = None
                 flag = False
                 def __init__(self):
                     self.data = None
                     self.ndata = None
                     self.profCounter = 1
                     self.codeIndex = 0
                     self.flag = False
                     self.code = None
                     self.ncode = None
                     self.nbaud = None
                     self.__isConfig = False
                 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=1)
                     fft_code = numpy.conj(numpy.fft.fft(newcode))
                     fft_code = fft_code.reshape(1,len(fft_code))
                     conv = fft_data.copy()
                     conv.fill(0)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=1)
                     self.data = data[:,:-self.nbaud+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)
                     self.data = conv
                     self.flag = True
                     if self.profCounter == self.ncode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
                 def run(self, dataOut, code=None, mode = 0):
                     if not(self.__isConfig):
                         if code == None:
                             code = dataOut.radarControllerHeaderObj.code
             #                code = dataOut.code
                         ncode, nbaud = code.shape
                         self.code = code
                         self.ncode = ncode
                         self.nbaud = nbaud
                         self.__isConfig = True
                     ndata = dataOut.data.shape[1]
                     if mode == 0:
                         self.convolutionInFreq(dataOut.data, ndata)
                     if mode == 1:
                         self.convolutionInTime(dataOut.data, ndata)
                     self.ndata = ndata - self.nbaud + 1
                     dataOut.data = self.data
                     dataOut.heightList = dataOut.heightList[:self.ndata]
                     dataOut.flagNoData = False

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