schain-jc Commit - r337:5789a59f83df

Modificaciones de graficos para SpectraHeis

Daniel Valdez -

r337:5789a59f83df

parent child

Context file:

r337:5789a59f83df

Collapse all files

schainpy/model/graphics/mpldriver.py +16 -15

             import numpy
             import datetime
             import sys
             import matplotlib
             if 'linux' in sys.platform:
                 matplotlib.use("TKAgg")
             if 'darwin' in sys.platform:
                 matplotlib.use("TKAgg")
             import matplotlib.pyplot
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import *
             ###########################################
             #Actualizacion de las funciones del driver
             ###########################################
             def createFigure(idfigure, wintitle, width, height, facecolor="w"):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.figure(num=idfigure, facecolor=facecolor)
                 fig.canvas.manager.set_window_title(wintitle)
                 fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 matplotlib.pyplot.show()
                 return fig
             def closeFigure():
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.show()
                 return
             def saveFigure(fig, filename):
                 matplotlib.pyplot.ioff()
                 fig.savefig(filename)
                 matplotlib.pyplot.ion()
             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.ioff()
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                     (xpos, ypos),
                                                     colspan=colspan,
                                                     rowspan=rowspan)
                 matplotlib.pyplot.ion()
                 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'
                 """
                 matplotlib.pyplot.ioff()
                 ax.set_xlim([xmin,xmax])
                 ax.set_ylim([ymin,ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
-                if (xmax-xmin)<=1:
+            #    if (xmax-xmin)<=1:
-                    xtickspos = numpy.linspace(xmin,xmax,nxticks)
+            #        xtickspos = numpy.linspace(xmin,xmax,nxticks)
-                    xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
+            #        xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
-                    ax.set_xticks(xtickspos)
+            #        ax.set_xticks(xtickspos)
-                else:
+            #    else:
-                    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
+            #        xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
-                    ax.set_xticks(xtickspos)
+            #        ax.set_xticks(xtickspos)
+            #
-                for tick in ax.get_xticklabels():
+            #    for tick in ax.get_xticklabels():
-                    tick.set_visible(xtick_visible)
+            #        tick.set_visible(xtick_visible)
+            #
-                for tick in ax.xaxis.get_major_ticks():
+            #    for tick in ax.xaxis.get_major_ticks():
-                    tick.label.set_fontsize(ticksize)
+            #        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)
                 ax.plot(x, y)
                 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()
                 matplotlib.pyplot.ion()
                 return iplot
             def set_linedata(ax, x, y, idline):
                 ax.lines[idline].set_data(x,y)
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def addpline(ax, x, y, color, linestyle, lw):
                 ax.plot(x,y,color=color,linestyle=linestyle,lw=lw)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize = 9,
                              colormap='jet',cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 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, 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))
                 matplotlib.pyplot.ion()
                 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='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
             def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.collections.remove(ax.collections[0])
                 ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
             def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 lines = ax.plot(x.T, y)
                 leg = ax.legend(lines, legendlabels, loc='upper right')
                 leg.get_frame().set_alpha(0.5)
                 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()
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x[i,:],y)
             def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                             ticksize=9, xtick_visible=True, ytick_visible=True,
-                            nxticks=4, nyticks=10, marker='^', markersize=8, linestyle="solid",
+                            nxticks=4, nyticks=10, marker='+', markersize=8, linestyle="solid",
                             grid=None, XAxisAsTime=False):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
-                lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
+            #    lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
+                lines = ax.plot(x, y.T, 'o', markersize=5)
                 leg = ax.legend(lines, legendlabels, loc='upper left', bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
                                 handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
                 for label in leg.get_texts(): label.set_fontsize(9)
                 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()
                 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))
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.get_axes()
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x,y[i,:])
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError, "This parameter should be of tpye matplotlib figure"
                 fig.canvas.draw()

schainpy/model/jroplot.py +19 -4

             import numpy
             import time, datetime, os
             from graphics.figure import  *
             class CrossSpectraPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 4
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     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,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r'):
                     """
                     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 pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     factor = dataOut.normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
             #        z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.abs(numpy.average(z, axis=1))
                     noise = dataOut.getNoise()/factor
                     zdB = 10*numpy.log10(z)
                     avgdB = 10*numpy.log10(avg)
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = "Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     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(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         self.__isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         title = "Channel %d: %4.2fdB" %(pair[0], noisedB[pair[0]])
                         zdB = 10.*numpy.log10(dataOut.data_spc[pair[0],:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         title = "Channel %d: %4.2fdB" %(pair[1], noisedB[pair[1]])
                         zdB = 10.*numpy.log10(dataOut.data_spc[pair[1],:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, 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
                         phase = numpy.arctan2(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=0, zmax=1,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, 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, colormap=phase_cmap, cblabel='')
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         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 = 2*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 150
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counterftp = 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 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, ftp=False, ftpratio=1):
                     """
                     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
                     factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
                     thisDatetime = dataOut.datatime
                     title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     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(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.__isConfig = True
                     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]
                         zdB = avgdB[i].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     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(avgdB[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     if save:
                         if figfile == None:
                             figfile = self.getFilename(name = self.name)
                         self.saveFigure(figpath, figfile)
                         self.counterftp += 1
                         if (ftp and (self.counterftp==ftpratio)):
                             figfilename = os.path.join(figpath,figfile)
                             self.sendByFTP(figfilename)
                             self.counterftp = 0
                     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 = 230
                     self.HEIGHT = 250
                     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))
                     factor = dataOut.normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.getNoise()/factor
                     zdB = 10*numpy.log10(z)
                     avgdB = 10*numpy.log10(avg)
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = "Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     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(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         self.__isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         title = "Channel %d: %4.2fdB" %(dataOut.channelList[i], noisedB[i])
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[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(avgdB[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[i], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         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.nplots = nplots
                     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)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=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[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                     y = y.real
                     thisDatetime = dataOut.datatime
                     title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         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
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(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:
                         date = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         if figfile == None:
                             figfile = self.getFilename(name = date)
                         self.saveFigure(figpath, figfile)
             class ProfilePlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 300
                     self.HEIGHT = 500
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(idfigure = idfigure,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT)
                     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)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     x = dataOut.data_spc[channelIndexList,:,:]/factor
                     x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     avg = numpy.average(x, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     thisDatetime = dataOut.datatime
                     title = "Power Profile"
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.__isConfig:
                         nplots = 1
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(avgdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(avgdB)*0.9
                         self.__isConfig = True
                     self.setWinTitle(title)
                     title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["channel %d"%x for x in channelList]
                     axes.pmultiline(avgdB, y,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             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 CoherenceMap(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self):
                     self.timerange = 2*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 150
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counterftp = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     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()
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                 def run(self, dataOut, idfigure, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, ftp=False, ftpratio=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r'):
                     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 timerange != None:
                         self.timerange = timerange
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = "CoherenceMap: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if not self.__isConfig:
                         nplots = len(pairsIndexList)
                         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)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.__isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[pair[0],:,:]*dataOut.data_spc[pair[1],:,:])
                         avgcoherenceComplex = numpy.average(coherenceComplex, axis=0)
                         coherence = numpy.abs(avgcoherenceComplex)
             #            coherence = numpy.abs(coherenceComplex)
             #            avg = numpy.average(coherence, axis=0)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=0, zmax=1,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(coherence, y,
                                     xmin=0, xmax=1, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
             #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
             #            avg = numpy.average(phase, axis=0)
                         z = phase.reshape((1,-1))
                         title = "Phase %d%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2 + counter]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax, zmin=-180, zmax=180,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(phase, y,
                                     xmin=-180, xmax=180, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if save:
                         if figfile == None:
                             figfile = self.getFilename(name = self.name)
                         self.saveFigure(figpath, figfile)
                         self.counterftp += 1
                         if (ftp and (self.counterftp==ftpratio)):
                             figfilename = os.path.join(figpath,figfile)
                             self.sendByFTP(figfilename)
                             self.counterftp = 0
                     if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
                         self.__isConfig = False
             class RTIfromNoise(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'rtinoise'
                 def __init__(self):
                     self.timerange = 24*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 820
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     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()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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()
                     factor = dataOut.normFactor
                     noise = dataOut.getNoise()/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = "RTI Noise: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if not self.__isConfig:
                         nplots = 1
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         tmin, tmax = self.getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(noisedB)
                         if ymax == None: ymax = numpy.nanmax(noisedB)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.__isConfig = True
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                     self.setWinTitle(title)
                     title = "RTI Noise %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     legendlabels = ["channel %d"%idchannel for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = noisedB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True
                                 )
                     self.draw()
                     if save:
                         if figfile == None:
                             figfile = self.getFilename(name = self.name)
                         self.saveFigure(figpath, figfile)
                     if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
                         self.__isConfig = False
                         del self.xdata
                         del self.ydata
             class SpectraHeisScope(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 230
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
+                    self.counterftp = 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 = False
                     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
             #    __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.nplots = nplots
             #
             #        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)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
-                        figpath='./', figfile=None):
+                        figpath='./', figfile=None, ftp=False, ftpratio=1):
                     """
                     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
                     c   =  3E8
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     #deberia cambiar para el caso de 1Mhz y 100KHz
                     x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
                     x= x/(10000.0)
             #        y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
             #        y = y.real
                     datadB = 10.*numpy.log10(dataOut.data_spc)
                     y = datadB
                     thisDatetime = dataOut.datatime
                     title = "Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Frequency"
                     ylabel = "Intensity (dB)"
                     if not self.__isConfig:
                         nplots = len(channelIndexList)
                         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
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         ychannel = y[i,:]
                         title = "Channel %d - peak:%.2f" %(i,numpy.max(ychannel))
                         axes = self.axesList[i]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                     self.draw()
                     if save:
                         date = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         if figfile == None:
                             figfile = self.getFilename(name = date)
                         self.saveFigure(figpath, figfile)
+                        self.counterftp += 1
+                        if (ftp and (self.counterftp==ftpratio)):
+                            figfilename = os.path.join(figpath,figfile)
+                            self.sendByFTP(figfilename)
+                            self.counterftp = 0
             class RTIfromSpectraHeis(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'rtinoise'
                 def __init__(self):
                     self.timerange = 24*60*60
                     self.__isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 820
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
+                    self.counterftp = 0
                     self.xdata = None
                     self.ydata = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, idfigure, nplots, wintitle, showprofile=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     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()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, idfigure, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
-                        save=False, figpath='./', figfile=None):
+                        save=False, figpath='./', figfile=None, ftp=False, ftpratio=1):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     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()
                     factor = 1
                     data = dataOut.data_spc/factor
                     data = numpy.average(data,axis=1)
                     datadB = 10*numpy.log10(data)
             #        factor = dataOut.normFactor
             #        noise = dataOut.getNoise()/factor
             #        noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = "RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Intensity (dB)"
                     if not self.__isConfig:
                         nplots = 1
                         self.setup(idfigure=idfigure,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile)
                         tmin, tmax = self.getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(datadB)
                         if ymax == None: ymax = numpy.nanmax(datadB)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.__isConfig = True
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                     self.setWinTitle(title)
-                    title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
+            #        title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    title = "RTI-Noise - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     legendlabels = ["channel %d"%idchannel for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = datadB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=tmin, xmax=tmax, ymin=ymin, ymax=ymax,
-                                xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
+                                xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid",
                                 XAxisAsTime=True
                                 )
                     self.draw()
                     if save:
                         if figfile == None:
                             figfile = self.getFilename(name = self.name)
                         self.saveFigure(figpath, figfile)
+                        self.counterftp += 1
+                        if (ftp and (self.counterftp==ftpratio)):
+                            figfilename = os.path.join(figpath,figfile)
+                            self.sendByFTP(figfilename)
+                            self.counterftp = 0
                     if x[1] + (x[1]-x[0]) >= self.axesList[0].xmax:
                         self.__isConfig = False
                         del self.xdata
                         del self.ydata
   No newline at end of file

schainpy/test/SunExperiment.py +27 -21

             import os, sys
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from controller import *
-            desc = "EWDrifts Experiment Test"
+            desc = "Sun Experiment Test"
-            filename = "ewdrifts.xml"
+            filename = "sunexp.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='test01', description=desc)
+            #/Users/dsuarez/Documents/RadarData/SunExperiment
+            #/Volumes/data_e/PaseDelSol/Raw/100KHZ
             readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
-                                                        path='/Volumes/data_e/PaseDelSol/Raw/100KHZ',
+                                                        path='/Users/dsuarez/Documents/RadarData/SunExperiment',
                                                         startDate='2013/02/06',
                                                         endDate='2013/12/31',
-                                                        startTime='17:30:00',
+                                                        startTime='00:30:00',
                                                         endTime='17:40:59',
                                                         online=0,
+                                                        delay=3,
                                                         walk=1)
             procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
             procUnitConfObj1 = controllerObj.addProcUnit(datatype='SpectraHeis', inputId=procUnitConfObj0.getId())
             opObj11 = procUnitConfObj1.addOperation(name='IncohInt4SpectraHeis', optype='other')
             opObj11.addParameter(name='timeInterval', value='5', format='float')
             opObj11 = procUnitConfObj1.addOperation(name='SpectraHeisScope', optype='other')
             opObj11.addParameter(name='idfigure', value='10', format='int')
             opObj11.addParameter(name='wintitle', value='SpectraHeisPlot', format='str')
-            opObj11.addParameter(name='ymin', value='125', format='int')
+            #opObj11.addParameter(name='ymin', value='125', format='int')
-            opObj11.addParameter(name='ymax', value='140', format='int')
+            #opObj11.addParameter(name='ymax', value='140', format='int')
             #opObj11.addParameter(name='channelList', value='0,1,2', format='intlist')
             #opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value='1', format='bool')
+            opObj11.addParameter(name='figfile', value='spc-noise.png', format='str')
             opObj11.addParameter(name='figpath', value='/Users/dsuarez/Pictures/sun_pics', format='str')
+            opObj11.addParameter(name='ftp', value='1', format='int')
+            opObj11.addParameter(name='ftpratio', value='10', format='int')
-            #opObj11 = procUnitConfObj1.addOperation(name='RTIfromSpectraHeis', optype='other')
-            #opObj11.addParameter(name='idfigure', value='6', format='int')
+            opObj11 = procUnitConfObj1.addOperation(name='RTIfromSpectraHeis', optype='other')
-            #opObj11.addParameter(name='wintitle', value='RTIPLot', format='str')
+            opObj11.addParameter(name='idfigure', value='6', format='int')
-            ##opObj11.addParameter(name='zmin', value='10', format='int')
+            opObj11.addParameter(name='wintitle', value='RTIPLot', format='str')
-            ##opObj11.addParameter(name='zmax', value='40', format='int')
+            #opObj11.addParameter(name='zmin', value='10', format='int')
-            #opObj11.addParameter(name='ymin', value='60', format='int')
+            #opObj11.addParameter(name='zmax', value='40', format='int')
-            #opObj11.addParameter(name='ymax', value='130', format='int')
+            opObj11.addParameter(name='ymin', value='60', format='int')
-            ##opObj11.addParameter(name='channelList', value='0,1,2,3', format='intlist')
+            opObj11.addParameter(name='ymax', value='85', format='int')
+            #opObj11.addParameter(name='channelList', value='0,1,2,3', format='intlist')
             #opObj11.addParameter(name='timerange', value='600', format='int')
-            ##opObj11.addParameter(name='showprofile', value='0', format='int')
+            #opObj11.addParameter(name='showprofile', value='0', format='int')
-            #opObj11.addParameter(name='save', value='1', format='bool')
+            opObj11.addParameter(name='save', value='1', format='bool')
-            #opObj11.addParameter(name='figpath', value='/Users/dsuarez/Pictures/sun_pics', format='str')
+            opObj11.addParameter(name='figfile', value='rti-noise.png', format='str')
+            opObj11.addParameter(name='figpath', value='/Users/dsuarez/Pictures/sun_pics', format='str')
+            opObj11.addParameter(name='ftp', value='1', format='int')
+            opObj11.addParameter(name='ftpratio', value='10', format='int')
             print "Escribiendo el archivo XML"
             controllerObj.writeXml(filename)
             print "Leyendo el archivo XML"
             controllerObj.readXml(filename)
             controllerObj.createObjects()
             controllerObj.connectObjects()
             controllerObj.run()
   No newline at end of file

General Comments 0

Write
Preview

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

No TODOs yet

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

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