schain Commit - r1027:f11c2da27e74 · Jicamarca Repository

07/09/2017

ebocanegra -

r1027:f11c2da27e74

parent child

Context file:

r1027:f11c2da27e74

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schainpy/model/graphics/jroplot_spectra.py +43 0

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
+            import matplotlib.pyplot as plt
             from figure import Figure, isRealtime, isTimeInHourRange
             from plotting_codes import *
+            from matplotlib.pyplot import savefig
             class SpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
+                    self.indice=1
                 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, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     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, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print 'Skipping this plot function'
                             return
                     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" %channel
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.getNoise()/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
+                    print 'len de X',len(x), numpy.shape(x), 'len de spc line',len(dataOut.data_spc[1,:,15]), numpy.shape(dataOut.data_spc)
+                    print 'Altura:', y[0], y[1], y[13], y[14], y[10]
+                    #a=z[1,:,15]
+            #         fig = plt.figure(10+self.indice)
+            #         plt.plot( x[0:128], zdB[0,:,10] )
+            #         plt.axis([-12, 12, 15, 50])
+            #         plt.title(" %s" %(  '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S")))   )
+            #         plt.ylabel('Intensidad [dB]')
+            #         plt.xlabel('Velocidad [m/s]')
+            #         fig.savefig('/home/erick/Documents/Pics/to{}.png'.format(self.indice))
+            #
+            #         plt.show()
+            #
+            #         self.indice=self.indice+1
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         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.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class CrossSpectraPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 4
                     self.counter_imagwr = 0
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                     self.PLOT_CODE = CROSS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
+                    self.indice=0
                 def getSubplots(self):
                     ncol = 4
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     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, id, wintitle="", pairsList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         coh_min=None, coh_max=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None,
                         xaxis='frequency'):
                     """
                     Input:
                         dataOut         :
                         id        :
                         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" %str(pair)
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if not pairsIndexList:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     noisedB = 10*numpy.log10(noise)
                     if coh_min == None:
                         coh_min = 0.0
                     if coh_max == None:
                         coh_max = 1.0
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
             #         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=False,
                                    show=show)
                         avg = numpy.abs(numpy.average(z, axis=1))
                         avgdB = 10*numpy.log10(avg)
                         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.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         chan_index0 = dataOut.channelList.index(pair[0])
                         chan_index1 = dataOut.channelList.index(pair[1])
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[chan_index0], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index0,:,:]/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 = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[chan_index1], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index1,:,:]/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[chan_index0,:,:]*dataOut.data_spc[chan_index1,:,:])
                         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
+            #             print 'FASE', numpy.shape(phase), y[10]
+            #             fig = plt.figure(10+self.indice)
+            #             plt.plot( x[0:128],phase[:,10] )
+            #             #plt.axis([-12, 12, 15, 50])
+            #             plt.title("%s" %(  '%s %s, Channel %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S") , i)))
+            #             plt.ylabel('Desfase [grados]')
+            #             plt.xlabel('Velocidad [m/s]')
+            #             fig.savefig('/home/erick/Documents/Pics/to{}.png'.format(self.indice))
+            #
+            #             plt.show()
+            #             self.indice=self.indice+1
                         title = "Coherence Ch%d * Ch%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=coh_min, zmax=coh_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, cblabel='')
                         title = "Phase Ch%d * Ch%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=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=phase_cmap, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class RTIPlot(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     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, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, colormap='jet',
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #colormap = kwargs.get('colormap', 'jet')
                     if HEIGHT is not None:
                         self.HEIGHT  = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     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 normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
             #         factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
                     # avgdB = dataOut.getPower()
                     thisDatetime = dataOut.datatime
             #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         noise = dataOut.noise/factor
                         noisedB = 10*numpy.log10(noise)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         axes = self.axesList[i*self.__nsubplots]
                         zdB = avgdB[index].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
             class CoherenceMap(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = COH_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.counter_imagwr = 0
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     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, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     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]
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0.
                         if zmax == None: zmax = 1.
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         coherence = numpy.abs(avgcoherenceComplex)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence Ch%d * Ch%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=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     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=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         z = phase.reshape((1,-1))
                         title = "Phase Ch%d * Ch%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=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     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=phase_min, xmax=phase_max, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
             class PowerProfilePlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 300
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     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, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=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()
                     #for voltage
                     if dataOut.type == 'Voltage':
                         x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                         x = x.real
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     #for spectra
                     if dataOut.type == 'Spectra':
                         x = dataOut.data_spc[channelIndexList,:,:]/factor
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                         x = numpy.average(x, axis=1)
                     xdB = 10*numpy.log10(x)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(xdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(xdB)*1.1
                         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(xdB, 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()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class SpectraCutPlot(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc_cut'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 700
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     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, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None,
                         xaxis="frequency"):
                     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()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     hei_index = numpy.arange(25)*3 + 20
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange()/1000.
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Frequency (kHz)"
                         ylabel = "Power (dB)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange()
                         zdB = z[0,:,hei_index]
                         xlabel = "Time (ms)"
                         ylabel = "ACF"
                     else:
                         x = dataOut.getVelRange()
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Velocity (m/s)"
                         ylabel = "Power (dB)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Range Cuts %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)*0.9
                         if xmax == None: xmax = numpy.nanmax(x)*1.1
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Spectra Cuts: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["Range = %dKm" %y[i] for i in hei_index]
                     axes.pmultilineyaxis( x, zdB,
                             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()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class Noise(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'noise'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = NOISE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def openfile(self, filename):
                     dirname = os.path.dirname(filename)
                     if not os.path.exists(dirname):
                         os.mkdir(dirname)
                     f = open(filename,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
                     f.write('DD MM YYYY  HH MM SS   Channel0    Channel1    Channel2    Channel3\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     data_msg = ''
                     for i in range(len(data)):
                         data_msg += str(data[i]) + '  '
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   ' + data_msg + '\n')
                     f.close()
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     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))
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     noise = dataOut.noise[channelIndexList]/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Intensity (dB)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
                         if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         noise_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_noise = os.path.join(figpath,noise_file)
                     self.setWinTitle(title)
                     title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %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 = noisedB.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     #store data beacon phase
                     if save:
                         self.save_data(self.filename_noise, noisedB, thisDatetime)
             class BeaconPhase(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     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]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         #print "Phase %d%d" %(pair[0], pair[1])
                         #print phase[dataOut.beacon_heiIndexList]
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)

schainpy/model/graphics/jroplot_spectra.pyc binary modified 0 0

NO CONTENT: modified file, binary diff hidden

schainpy/model/io/jroIO_bltr.py +1 0

             import os, sys
             import glob
             import fnmatch
             import datetime
             import time
             import re
             import h5py
             import numpy
             import matplotlib.pyplot as plt
             import pylab as plb
             from scipy.optimize import curve_fit
             from scipy import asarray as ar,exp
             from scipy import stats
             from duplicity.path import Path
             from numpy.ma.core import getdata
             SPEED_OF_LIGHT = 299792458
             SPEED_OF_LIGHT = 3e8
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             from schainpy.model.data.jrodata import Spectra
             #from schainpy.model.data.BLTRheaderIO import FileHeader, RecordHeader
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
             #from schainpy.model.io.jroIO_bltr import BLTRReader
             from numpy import imag, shape, NaN
             from jroIO_base import JRODataReader
             class Header(object):
                 def __init__(self):
                     raise NotImplementedError
                 def read(self):
                     raise NotImplementedError
                 def write(self):
                     raise NotImplementedError
                 def printInfo(self):
                     message = "#"*50 + "\n"
                     message += self.__class__.__name__.upper() + "\n"
                     message += "#"*50 + "\n"
                     keyList = self.__dict__.keys()
                     keyList.sort()
                     for key in keyList:
                         message += "%s = %s" %(key, self.__dict__[key]) + "\n"
                     if "size" not in keyList:
                         attr = getattr(self, "size")
                         if attr:
                             message += "%s = %s" %("size", attr) + "\n"
                     #print message
             FILE_STRUCTURE = numpy.dtype([          #HEADER 48bytes
                                       ('FileMgcNumber','<u4'),      #0x23020100
                                       ('nFDTdataRecors','<u4'),     #No Of FDT data records in this file (0 or more)
                                       ('OffsetStartHeader','<u4'),
                                       ('RadarUnitId','<u4'),
                                       ('SiteName',numpy.str_,32),          #Null terminated
                                       ])
             class FileHeaderBLTR(Header):
                 def __init__(self):
                     self.FileMgcNumber= 0     #0x23020100
                     self.nFDTdataRecors=0     #No Of FDT data records in this file (0 or more)
                     self.RadarUnitId= 0
                     self.OffsetStartHeader=0
                     self.SiteName= ""
                     self.size = 48
                 def FHread(self, fp):
                     #try:
                     startFp = open(fp,"rb")
                     header = numpy.fromfile(startFp, FILE_STRUCTURE,1)
                     print ' '
                     print 'puntero file header', startFp.tell()
                     print ' '
                     '''      numpy.fromfile(file, dtype, count, sep='')
                         file : file or str
                         Open file object or filename.
                         dtype : data-type
                         Data type of the returned array. For binary files, it is used to determine
                         the size and byte-order of the items in the file.
                         count : int
                         Number of items to read. -1 means all items (i.e., the complete file).
                         sep : str
                         Separator between items if file is a text file. Empty ("") separator means
                         the file should be treated as binary. Spaces (" ") in the separator match zero
                         or more whitespace characters. A separator consisting only of spaces must match
                         at least one whitespace.
                 '''
                     self.FileMgcNumber= hex(header['FileMgcNumber'][0])
                     self.nFDTdataRecors=int(header['nFDTdataRecors'][0])     #No Of FDT data records in this file (0 or more)
                     self.RadarUnitId= int(header['RadarUnitId'][0])
                     self.OffsetStartHeader= int(header['OffsetStartHeader'][0])
                     self.SiteName= str(header['SiteName'][0])
                     #print 'Numero de bloques', self.nFDTdataRecors
                     if self.size <48:
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.FileMgcNumber,
                                    self.nFDTdataRecors,
                                    self.RadarUnitId,
                                    self.SiteName,
                                    self.size)
                     header = numpy.array(headerTuple, FILE_STRUCTURE)
                     #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
                     header.tofile(fp)
                     ''' ndarray.tofile(fid, sep, format)    Write array to a file as text or binary (default).
                     fid : file or str
                     An open file object, or a string containing a filename.
                     sep : str
                     Separator between array items for text output. If "" (empty), a binary file is written,
                     equivalent to file.write(a.tobytes()).
                     format : str
                     Format string for text file output. Each entry in the array is formatted to text by
                     first converting it to the closest Python type, and then using "format" % item.
                     '''
                     return 1
             RECORD_STRUCTURE = numpy.dtype([         #RECORD HEADER 180+20N bytes
                                         ('RecMgcNumber','<u4'),     #0x23030001
                                         ('RecCounter','<u4'),       #Record counter(0,1, ...)
                                         ('Off2StartNxtRec','<u4'),  #Offset to start of next record form start of this record
                                         ('Off2StartData','<u4'),    #Offset to start of data from start of this record
                                         ('nUtime','<i4'),      #Epoch time stamp of start of acquisition (seconds)
                                         ('nMilisec','<u4'),      #Millisecond component of time stamp (0,...,999)
                                         ('ExpTagName',numpy.str_,32),      #Experiment tag name (null terminated)
                                         ('ExpComment',numpy.str_,32),      #Experiment comment (null terminated)
                                         ('SiteLatDegrees','<f4'),   #Site latitude (from GPS) in degrees (positive implies North)
                                         ('SiteLongDegrees','<f4'),  #Site longitude (from GPS) in degrees (positive implies East)
                                         ('RTCgpsStatus','<u4'),     #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
                                         ('TransmitFrec','<u4'),     #Transmit frequency (Hz)
                                         ('ReceiveFrec','<u4'),      #Receive frequency
                                         ('FirstOsciFrec','<u4'),    #First local oscillator frequency (Hz)
                                         ('Polarisation','<u4'),     #(0="O", 1="E", 2="linear 1", 3="linear2")
                                         ('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)
                                         ('nModesInUse','<u4'),      #Number of modes in use (1 or 2)
                                         ('DualModeIndex','<u4'),    #Dual Mode index number for these data (0 or 1)
                                         ('DualModeRange','<u4'),    #Dual Mode range correction for these data (m)
                                         ('nDigChannels','<u4'),     #Number of digital channels acquired (2*N)
                                         ('SampResolution','<u4'),   #Sampling resolution (meters)
                                         ('nHeights','<u4'),         #Number of range gates sampled
                                         ('StartRangeSamp','<u4'),   #Start range of sampling (meters)
                                         ('PRFhz','<u4'),            #PRF (Hz)
                                         ('nCohInt','<u4'),          #Integrations
                                         ('nProfiles','<u4'),        #Number of data points transformed
                                         ('nChannels','<u4'),        #Number of receive beams stored in file (1 or N)
                                         ('nIncohInt','<u4'),        #Number of spectral averages
                                         ('FFTwindowingInd','<u4'),  #FFT windowing index (0 = no window)
                                         ('BeamAngleAzim','<f4'),    #Beam steer angle (azimuth) in degrees (clockwise from true North)
                                         ('BeamAngleZen','<f4'),     #Beam steer angle (zenith) in degrees (0=> vertical)
                                         ('AntennaCoord0','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl0','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaCoord1','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl1','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaCoord2','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('AntennaAngl2','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
                                         ('RecPhaseCalibr0','<f4'),  #Receiver phase calibration (degrees) - N values
                                         ('RecPhaseCalibr1','<f4'),  #Receiver phase calibration (degrees) - N values
                                         ('RecPhaseCalibr2','<f4'),  #Receiver phase calibration (degrees) - N values
                                         ('RecAmpCalibr0','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('RecAmpCalibr1','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('RecAmpCalibr2','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
                                         ('ReceiverGaindB0','<i4'),  #Receiver gains in dB - N values
                                         ('ReceiverGaindB1','<i4'),  #Receiver gains in dB - N values
                                         ('ReceiverGaindB2','<i4'),  #Receiver gains in dB - N values
                                         ])
             class RecordHeaderBLTR(Header):
                 def __init__(self,      RecMgcNumber=None,   RecCounter= 0,      Off2StartNxtRec= 811248,
                                         nUtime= 0,           nMilisec= 0,        ExpTagName= None,
                                         ExpComment=None,     SiteLatDegrees=0,   SiteLongDegrees= 0,
                                         RTCgpsStatus= 0,     TransmitFrec= 0,    ReceiveFrec= 0,
                                         FirstOsciFrec= 0,    Polarisation= 0,    ReceiverFiltSett= 0,
                                         nModesInUse= 0,      DualModeIndex= 0,   DualModeRange= 0,
                                         nDigChannels= 0,     SampResolution= 0,  nHeights= 0,
                                         StartRangeSamp= 0,   PRFhz= 0,           nCohInt= 0,
                                         nProfiles= 0,        nChannels= 0,       nIncohInt= 0,
                                         FFTwindowingInd= 0,  BeamAngleAzim= 0,   BeamAngleZen= 0,
                                         AntennaCoord0= 0,     AntennaCoord1= 0,    AntennaCoord2= 0,
                                         RecPhaseCalibr0= 0,  RecPhaseCalibr1= 0, RecPhaseCalibr2= 0,
                                         RecAmpCalibr0= 0,    RecAmpCalibr1= 0,   RecAmpCalibr2= 0,
                                         AntennaAngl0=0,      AntennaAngl1=0,     AntennaAngl2=0,
                                         ReceiverGaindB0= 0,  ReceiverGaindB1= 0, ReceiverGaindB2= 0, Off2StartData=0,    OffsetStartHeader=0):
                     self.RecMgcNumber = RecMgcNumber     #0x23030001
                     self.RecCounter = RecCounter
                     self.Off2StartNxtRec = Off2StartNxtRec
                     self.Off2StartData = Off2StartData
                     self.nUtime = nUtime
                     self.nMilisec = nMilisec
                     self.ExpTagName = ExpTagName
                     self.ExpComment = ExpComment
                     self.SiteLatDegrees = SiteLatDegrees
                     self.SiteLongDegrees = SiteLongDegrees
                     self.RTCgpsStatus = RTCgpsStatus
                     self.TransmitFrec = TransmitFrec
                     self.ReceiveFrec = ReceiveFrec
                     self.FirstOsciFrec = FirstOsciFrec
                     self.Polarisation = Polarisation
                     self.ReceiverFiltSett = ReceiverFiltSett
                     self.nModesInUse = nModesInUse
                     self.DualModeIndex = DualModeIndex
                     self.DualModeRange = DualModeRange
                     self.nDigChannels = nDigChannels
                     self.SampResolution = SampResolution
                     self.nHeights = nHeights
                     self.StartRangeSamp = StartRangeSamp
                     self.PRFhz = PRFhz
                     self.nCohInt = nCohInt
                     self.nProfiles = nProfiles
                     self.nChannels = nChannels
                     self.nIncohInt = nIncohInt
                     self.FFTwindowingInd = FFTwindowingInd
                     self.BeamAngleAzim = BeamAngleAzim
                     self.BeamAngleZen = BeamAngleZen
                     self.AntennaCoord0 = AntennaCoord0
                     self.AntennaAngl0 = AntennaAngl0
                     self.AntennaAngl1 = AntennaAngl1
                     self.AntennaAngl2 = AntennaAngl2
                     self.AntennaCoord1 = AntennaCoord1
                     self.AntennaCoord2 = AntennaCoord2
                     self.RecPhaseCalibr0 = RecPhaseCalibr0
                     self.RecPhaseCalibr1 = RecPhaseCalibr1
                     self.RecPhaseCalibr2 = RecPhaseCalibr2
                     self.RecAmpCalibr0 = RecAmpCalibr0
                     self.RecAmpCalibr1 = RecAmpCalibr1
                     self.RecAmpCalibr2 = RecAmpCalibr2
                     self.ReceiverGaindB0 = ReceiverGaindB0
                     self.ReceiverGaindB1 = ReceiverGaindB1
                     self.ReceiverGaindB2 = ReceiverGaindB2
                     self.OffsetStartHeader =  48
                 def RHread(self, fp):
                     #print fp
                     #startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
                     startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
                     #RecCounter=0
                     #Off2StartNxtRec=811248
                     OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
                     print ' '
                     print 'puntero Record Header', startFp.tell()
                     print ' '
                     startFp.seek(OffRHeader, os.SEEK_SET)
                     print ' '
                     print 'puntero Record Header con seek', startFp.tell()
                     print ' '
                     #print 'Posicion del bloque:        ',OffRHeader
                     header = numpy.fromfile(startFp,RECORD_STRUCTURE,1)
                     print ' '
                     print 'puntero Record Header con seek', startFp.tell()
                     print ' '
                     print ' '
                     #
                     #print 'puntero Record Header despues de seek', header.tell()
                     print ' '
                     self.RecMgcNumber = hex(header['RecMgcNumber'][0])     #0x23030001
                     self.RecCounter = int(header['RecCounter'][0])
                     self.Off2StartNxtRec = int(header['Off2StartNxtRec'][0])
                     self.Off2StartData = int(header['Off2StartData'][0])
                     self.nUtime = header['nUtime'][0]
                     self.nMilisec = header['nMilisec'][0]
                     self.ExpTagName = str(header['ExpTagName'][0])
                     self.ExpComment = str(header['ExpComment'][0])
                     self.SiteLatDegrees = header['SiteLatDegrees'][0]
                     self.SiteLongDegrees = header['SiteLongDegrees'][0]
                     self.RTCgpsStatus = header['RTCgpsStatus'][0]
                     self.TransmitFrec = header['TransmitFrec'][0]
                     self.ReceiveFrec = header['ReceiveFrec'][0]
                     self.FirstOsciFrec = header['FirstOsciFrec'][0]
                     self.Polarisation = header['Polarisation'][0]
                     self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
                     self.nModesInUse = header['nModesInUse'][0]
                     self.DualModeIndex = header['DualModeIndex'][0]
                     self.DualModeRange = header['DualModeRange'][0]
                     self.nDigChannels = header['nDigChannels'][0]
                     self.SampResolution = header['SampResolution'][0]
                     self.nHeights = header['nHeights'][0]
                     self.StartRangeSamp = header['StartRangeSamp'][0]
                     self.PRFhz = header['PRFhz'][0]
                     self.nCohInt = header['nCohInt'][0]
                     self.nProfiles = header['nProfiles'][0]
                     self.nChannels = header['nChannels'][0]
                     self.nIncohInt = header['nIncohInt'][0]
                     self.FFTwindowingInd = header['FFTwindowingInd'][0]
                     self.BeamAngleAzim = header['BeamAngleAzim'][0]
                     self.BeamAngleZen = header['BeamAngleZen'][0]
                     self.AntennaCoord0 = header['AntennaCoord0'][0]
                     self.AntennaAngl0 = header['AntennaAngl0'][0]
                     self.AntennaCoord1 = header['AntennaCoord1'][0]
                     self.AntennaAngl1 = header['AntennaAngl1'][0]
                     self.AntennaCoord2 = header['AntennaCoord2'][0]
                     self.AntennaAngl2 = header['AntennaAngl2'][0]
                     self.RecPhaseCalibr0 = header['RecPhaseCalibr0'][0]
                     self.RecPhaseCalibr1 = header['RecPhaseCalibr1'][0]
                     self.RecPhaseCalibr2 = header['RecPhaseCalibr2'][0]
                     self.RecAmpCalibr0 = header['RecAmpCalibr0'][0]
                     self.RecAmpCalibr1 = header['RecAmpCalibr1'][0]
                     self.RecAmpCalibr2 = header['RecAmpCalibr2'][0]
                     self.ReceiverGaindB0 = header['ReceiverGaindB0'][0]
                     self.ReceiverGaindB1 = header['ReceiverGaindB1'][0]
                     self.ReceiverGaindB2 = header['ReceiverGaindB2'][0]
                     self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
                     self.RHsize = 180+20*self.nChannels
                     self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
                     #print 'Datasize',self.Datasize
                     endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
                     print '=============================================='
                     print 'RecMgcNumber         ',self.RecMgcNumber
                     print 'RecCounter           ',self.RecCounter
                     print 'Off2StartNxtRec      ',self.Off2StartNxtRec
                     print 'Off2StartData        ',self.Off2StartData
                     print 'Range Resolution     ',self.SampResolution
                     print 'First Height         ',self.StartRangeSamp
                     print 'PRF (Hz)             ',self.PRFhz
                     print 'Heights (K)          ',self.nHeights
                     print 'Channels (N)         ',self.nChannels
                     print 'Profiles (J)         ',self.nProfiles
                     print 'iCoh                 ',self.nCohInt
                     print 'iInCoh               ',self.nIncohInt
                     print 'BeamAngleAzim        ',self.BeamAngleAzim
                     print 'BeamAngleZen         ',self.BeamAngleZen
                     #print 'ModoEnUso            ',self.DualModeIndex
                     #print 'UtcTime              ',self.nUtime
                     #print 'MiliSec              ',self.nMilisec
                     #print 'Exp TagName          ',self.ExpTagName
                     #print 'Exp Comment          ',self.ExpComment
                     #print 'FFT Window Index     ',self.FFTwindowingInd
                     #print 'N Dig. Channels      ',self.nDigChannels
                     print 'Size de bloque       ',self.RHsize
                     print 'DataSize             ',self.Datasize
                     print 'BeamAngleAzim        ',self.BeamAngleAzim
                     #print 'AntennaCoord0        ',self.AntennaCoord0
                     #print 'AntennaAngl0         ',self.AntennaAngl0
                     #print 'AntennaCoord1        ',self.AntennaCoord1
                     #print 'AntennaAngl1         ',self.AntennaAngl1
                     #print 'AntennaCoord2        ',self.AntennaCoord2
                     #print 'AntennaAngl2         ',self.AntennaAngl2
                     print 'RecPhaseCalibr0      ',self.RecPhaseCalibr0
                     print 'RecPhaseCalibr1      ',self.RecPhaseCalibr1
                     print 'RecPhaseCalibr2      ',self.RecPhaseCalibr2
                     print 'RecAmpCalibr0        ',self.RecAmpCalibr0
                     print 'RecAmpCalibr1        ',self.RecAmpCalibr1
                     print 'RecAmpCalibr2        ',self.RecAmpCalibr2
                     print 'ReceiverGaindB0      ',self.ReceiverGaindB0
                     print 'ReceiverGaindB1      ',self.ReceiverGaindB1
                     print 'ReceiverGaindB2      ',self.ReceiverGaindB2
                     print '=============================================='
                     if OffRHeader > endFp:
                         sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp)
                         return 0
                     if OffRHeader < endFp:
                         sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp)
                         return 0
                     return 1
             class BLTRReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODataReader):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 walk = None
                 isConfig = False
                 fileList= None
                 #metadata
                 TimeZone= None
                 Interval= None
                 heightList= None
                 #data
                 data= None
                 utctime= None
                 def __init__(self, **kwargs):
                     #Eliminar de la base la herencia
                     ProcessingUnit.__init__(self, **kwargs)
             #         self.isConfig = False
                     #self.pts2read_SelfSpectra = 0
                     #self.pts2read_CrossSpectra = 0
                     #self.pts2read_DCchannels = 0
                     #self.datablock = None
                     self.utc = None
                     self.ext = ".fdt"
                     self.optchar = "P"
                     self.fpFile=None
                     self.fp = None
                     self.BlockCounter=0
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.fileSelector = 0
                     self.Off2StartNxtRec=0
                     self.RecCounter=0
                     self.flagNoMoreFiles = 0
                     self.data_spc=None
                     self.data_cspc=None
                     self.data_output=None
                     self.path = None
                     self.OffsetStartHeader=0
                     self.Off2StartData=0
                     self.ipp = 0
                     self.nFDTdataRecors=0
                     self.blocksize = 0
                     self.dataOut = Spectra()
                     self.profileIndex = 1 #Always
                     self.dataOut.flagNoData=False
                     self.dataOut.nRdPairs = 0
                     self.dataOut.pairsList = []
                     self.dataOut.data_spc=None
                     self.dataOut.noise=[]
                     self.dataOut.velocityX=[]
                     self.dataOut.velocityY=[]
                     self.dataOut.velocityV=[]
                 def Files2Read(self, fp):
                     '''
                     Function that indicates the number of .fdt files that exist in the folder to be read.
                     It also creates an organized list with the names of the files to read.
                     '''
                     #self.__checkPath()
                     ListaData=os.listdir(fp)    #Gets the list of files within the fp address
                     ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
                     nFiles=0                    #File Counter
                     FileList=[]                 #A list is created that will contain the .fdt files
                     for IndexFile in ListaData :
                         if  '.fdt' in IndexFile:
                             FileList.append(IndexFile)
                             nFiles+=1
                     #print 'Files2Read'
                     #print 'Existen '+str(nFiles)+' archivos .fdt'
                     self.filenameList=FileList #List of files from least to largest by names
                 def run(self, **kwargs):
                     '''
                     This method will be the one that will initiate the data entry, will be called constantly.
                     You should first verify that your Setup () is set up and then continue to acquire
                     the data to be processed with getData ().
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
                     #print 'running'
                 def setup(self, path=None,
                                 startDate=None,
                                 endDate=None,
                                 startTime=None,
                                 endTime=None,
                                 walk=True,
                                 timezone='utc',
                                 code = None,
                                 online=False,
                                 ReadMode=None,
                                 **kwargs):
                     self.isConfig = True
                     self.path=path
                     self.startDate=startDate
                     self.endDate=endDate
                     self.startTime=startTime
                     self.endTime=endTime
                     self.walk=walk
                     self.ReadMode=int(ReadMode)
                     pass
                 def getData(self):
                     '''
                     Before starting this function, you should check that there is still an unread file,
                     If there are still blocks to read or if the data block is empty.
                     You should call the file "read".
                     '''
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'NoData se vuelve true'
                         return 0
                     self.fp=self.path
                     self.Files2Read(self.fp)
                     self.readFile(self.fp)
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc =self.data_cspc
                     self.dataOut.data_output=self.data_output
                     print 'self.dataOut.data_output', shape(self.dataOut.data_output)
                     #self.removeDC()
                     return self.dataOut.data_spc
                 def readFile(self,fp):
                     '''
                     You must indicate if you are reading in Online or Offline mode and load the
                     The parameters for this file reading mode.
                     Then you must do 2 actions:
 . Get the BLTR FileHeader.
 . Start reading the first block.
                     '''
                     #The address of the folder is generated the name of the .fdt file that will be read
                     print "File:    ",self.fileSelector+1
                     if self.fileSelector < len(self.filenameList):
                         self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
                         #print self.fpFile
                         fheader = FileHeaderBLTR()
                         fheader.FHread(self.fpFile)   #Bltr FileHeader Reading
                         self.nFDTdataRecors=fheader.nFDTdataRecors
                         self.readBlock()    #Block reading
                     else:
                         print 'readFile FlagNoData becomes true'
                         self.flagNoMoreFiles=True
                         self.dataOut.flagNoData = True
                         return 0
                 def getVelRange(self, extrapoints=0):
                                 Lambda= SPEED_OF_LIGHT/50000000
                                 PRF = self.dataOut.PRF#1./(self.dataOut.ippSeconds * self.dataOut.nCohInt)
                                 Vmax=-Lambda/(4.*(1./PRF)*self.dataOut.nCohInt*2.)
                                 deltafreq = PRF / (self.nProfiles)
                                 deltavel = (Vmax*2) / (self.nProfiles)
                                 freqrange = deltafreq*(numpy.arange(self.nProfiles)-self.nProfiles/2.) - deltafreq/2
                                 velrange = deltavel*(numpy.arange(self.nProfiles)-self.nProfiles/2.)
                                 return velrange
                 def readBlock(self):
                     '''
                     It should be checked if the block has data, if it is not passed to the next file.
                     Then the following is done:
 . Read the RecordHeader
 . Fill the buffer with the current block number.
                     '''
                     if self.BlockCounter < self.nFDTdataRecors-2:
                         print self.nFDTdataRecors, 'CONDICION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
                         if self.ReadMode==1:
                             rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter+1)
                         elif self.ReadMode==0:
                             rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter)
                         rheader.RHread(self.fpFile)   #Bltr FileHeader Reading
                         self.OffsetStartHeader=rheader.OffsetStartHeader
                         self.RecCounter=rheader.RecCounter
                         self.Off2StartNxtRec=rheader.Off2StartNxtRec
                         self.Off2StartData=rheader.Off2StartData
                         self.nProfiles=rheader.nProfiles
                         self.nChannels=rheader.nChannels
                         self.nHeights=rheader.nHeights
                         self.frequency=rheader.TransmitFrec
                         self.DualModeIndex=rheader.DualModeIndex
                         self.pairsList =[(0,1),(0,2),(1,2)]
                         self.dataOut.pairsList = self.pairsList
                         self.nRdPairs=len(self.dataOut.pairsList)
                         self.dataOut.nRdPairs = self.nRdPairs
                         self.__firstHeigth=rheader.StartRangeSamp
                         self.__deltaHeigth=rheader.SampResolution
                         self.dataOut.heightList= self.__firstHeigth + numpy.array(range(self.nHeights))*self.__deltaHeigth
                         self.dataOut.channelList = range(self.nChannels)
                         self.dataOut.nProfiles=rheader.nProfiles
                         self.dataOut.nIncohInt=rheader.nIncohInt
                         self.dataOut.nCohInt=rheader.nCohInt
                         self.dataOut.ippSeconds= 1/float(rheader.PRFhz)
                         self.dataOut.PRF=rheader.PRFhz
                         self.dataOut.nFFTPoints=rheader.nProfiles
                         self.dataOut.utctime=rheader.nUtime
                         self.dataOut.timeZone=0
                         self.dataOut.normFactor= self.dataOut.nProfiles*self.dataOut.nIncohInt*self.dataOut.nCohInt
                         self.dataOut.outputInterval= self.dataOut.ippSeconds * self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
                         self.data_output=numpy.ones([3,rheader.nHeights])*numpy.NaN
                         print 'self.data_output', shape(self.data_output)
                         self.dataOut.velocityX=[]
                         self.dataOut.velocityY=[]
                         self.dataOut.velocityV=[]
                         '''Block Reading, the Block Data is received and Reshape is used to give it
                         shape.
                         '''
                         #Procedure to take the pointer to where the date block starts
                         startDATA = open(self.fpFile,"rb")
                         OffDATA= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec+self.Off2StartData
                         startDATA.seek(OffDATA, os.SEEK_SET)
                         def moving_average(x, N=2):
                             return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
                         def gaus(xSamples,a,x0,sigma):
                             return a*exp(-(xSamples-x0)**2/(2*sigma**2))
                         def Find(x,value):
                             for index in range(len(x)):
                                 if x[index]==value:
                                     return index
                         def pol2cart(rho, phi):
                             x = rho * numpy.cos(phi)
                             y = rho * numpy.sin(phi)
                             return(x, y)
                         if self.DualModeIndex==self.ReadMode:
                             self.data_fft = numpy.fromfile( startDATA, [('complex','<c8')],self.nProfiles*self.nChannels*self.nHeights )
                             self.data_fft=self.data_fft.astype(numpy.dtype('complex'))
                             self.data_block=numpy.reshape(self.data_fft,(self.nHeights, self.nChannels, self.nProfiles ))
                             self.data_block = numpy.transpose(self.data_block, (1,2,0))
                             copy = self.data_block.copy()
                             spc = copy * numpy.conjugate(copy)
                             self.data_spc = numpy.absolute(spc) # valor absoluto o magnitud
                             factor = self.dataOut.normFactor
                             z = self.data_spc.copy()#/factor
                             z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                             #zdB = 10*numpy.log10(z)
                             print ' '
                             print 'Z: '
                             print shape(z)
                             print ' '
                             print ' '
                             self.dataOut.data_spc=self.data_spc
                             self.noise = self.dataOut.getNoise(ymin_index=80, ymax_index=132)#/factor
                             #noisedB = 10*numpy.log10(self.noise)
                             ySamples=numpy.ones([3,self.nProfiles])
                             phase=numpy.ones([3,self.nProfiles])
                             CSPCSamples=numpy.ones([3,self.nProfiles],dtype=numpy.complex_)
                             coherence=numpy.ones([3,self.nProfiles])
                             PhaseSlope=numpy.ones(3)
                             PhaseInter=numpy.ones(3)
                             '''****** Getting CrossSpectra ******'''
                             cspc=self.data_block.copy()
                             self.data_cspc=self.data_block.copy()
                             xFrec=self.getVelRange(1)
                             VelRange=self.getVelRange(1)
                             self.dataOut.VelRange=VelRange
                             #print ' '
                             #print ' '
                             #print 'xFrec',xFrec
                             #print ' '
                             #print ' '
                             #Height=35
                             for i in range(self.nRdPairs):
                                 chan_index0 = self.dataOut.pairsList[i][0]
                                 chan_index1 = self.dataOut.pairsList[i][1]
                                 self.data_cspc[i,:,:]=cspc[chan_index0,:,:] * numpy.conjugate(cspc[chan_index1,:,:])
                                 '''Getting Eij and Nij'''
                                 (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
                                 (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
                                 (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
                                 E01=AntennaX0-AntennaX1
                                 N01=AntennaY0-AntennaY1
                                 E02=AntennaX0-AntennaX2
                                 N02=AntennaY0-AntennaY2
                                 E12=AntennaX1-AntennaX2
                                 N12=AntennaY1-AntennaY2
                                 self.ChanDist= numpy.array([[E01, N01],[E02,N02],[E12,N12]])
                                 self.dataOut.ChanDist = self.ChanDist
             #                 for Height in range(self.nHeights):
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         '''****** Line of Data SPC ******'''
             #                         zline=z[i,:,Height]
             #
             #                         '''****** DC is removed ******'''
             #                         DC=Find(zline,numpy.amax(zline))
             #                         zline[DC]=(zline[DC-1]+zline[DC+1])/2
             #
             #
             #                         '''****** SPC is normalized ******'''
             #                         FactNorm= zline.copy() / numpy.sum(zline.copy())
             #                         FactNorm= FactNorm/numpy.sum(FactNorm)
             #
             #                         SmoothSPC=moving_average(FactNorm,N=3)
             #
             #                         xSamples = ar(range(len(SmoothSPC)))
             #                         ySamples[i] = SmoothSPC-self.noise[i]
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         '''****** Line of Data CSPC ******'''
             #                         cspcLine=self.data_cspc[i,:,Height].copy()
             #
             #
             #
             #                         '''****** CSPC is normalized ******'''
             #                         chan_index0 = self.dataOut.pairsList[i][0]
             #                         chan_index1 = self.dataOut.pairsList[i][1]
             #                         CSPCFactor= numpy.sum(ySamples[chan_index0]) * numpy.sum(ySamples[chan_index1])
             #
             #
             #                         CSPCNorm= cspcLine.copy() / numpy.sqrt(CSPCFactor)
             #
             #
             #                         CSPCSamples[i] = CSPCNorm-self.noise[i]
             #                         coherence[i] = numpy.abs(CSPCSamples[i]) / numpy.sqrt(CSPCFactor)
             #
             #                         '''****** DC is removed ******'''
             #                         DC=Find(coherence[i],numpy.amax(coherence[i]))
             #                         coherence[i][DC]=(coherence[i][DC-1]+coherence[i][DC+1])/2
             #                         coherence[i]= moving_average(coherence[i],N=2)
             #
             #                         phase[i] = moving_average( numpy.arctan2(CSPCSamples[i].imag, CSPCSamples[i].real),N=1)#*180/numpy.pi
             #
             #
             #                     '''****** Getting fij width ******'''
             #
             #                     yMean=[]
             #                     yMean2=[]
             #
             #                     for j in range(len(ySamples[1])):
             #                         yMean=numpy.append(yMean,numpy.average([ySamples[0,j],ySamples[1,j],ySamples[2,j]]))
             #
             #                     '''******* Getting fitting Gaussian ******'''
             #                     meanGauss=sum(xSamples*yMean) / len(xSamples)
             #                     sigma=sum(yMean*(xSamples-meanGauss)**2) / len(xSamples)
             #                     #print 'Height',Height,'SNR', meanGauss/sigma**2
             #
             #                     if (abs(meanGauss/sigma**2) > 0.0001) :
             #
             #                         try:
             #                             popt,pcov = curve_fit(gaus,xSamples,yMean,p0=[1,meanGauss,sigma])
             #
             #                             if numpy.amax(popt)>numpy.amax(yMean)*0.3:
             #                                 FitGauss=gaus(xSamples,*popt)
             #
             #                             else:
             #                                 FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                                 print 'Verificador:     Dentro', Height
             #                         except RuntimeError:
             #
             #                             try:
             #                                 for j in range(len(ySamples[1])):
             #                                     yMean2=numpy.append(yMean2,numpy.average([ySamples[1,j],ySamples[2,j]]))
             #                                 popt,pcov = curve_fit(gaus,xSamples,yMean2,p0=[1,meanGauss,sigma])
             #                                 FitGauss=gaus(xSamples,*popt)
             #                                 print 'Verificador:     Exepcion1', Height
             #                             except RuntimeError:
             #
             #                                 try:
             #                                     popt,pcov = curve_fit(gaus,xSamples,ySamples[1],p0=[1,meanGauss,sigma])
             #                                     FitGauss=gaus(xSamples,*popt)
             #                                     print 'Verificador:     Exepcion2', Height
             #                                 except RuntimeError:
             #                                     FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                                     print 'Verificador:     Exepcion3', Height
             #                     else:
             #                         FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
             #                         #print 'Verificador:     Fuera', Height
             #
             #
             #
             #                     Maximun=numpy.amax(yMean)
             #                     eMinus1=Maximun*numpy.exp(-1)
             #
             #                     HWpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-eMinus1)))
             #                     HalfWidth= xFrec[HWpos]
             #                     GCpos=Find(FitGauss, numpy.amax(FitGauss))
             #                     Vpos=Find(FactNorm, numpy.amax(FactNorm))
             #                     #Vpos=numpy.sum(FactNorm)/len(FactNorm)
             #                     #Vpos=Find(FactNorm, min(FactNorm, key=lambda value:abs(value- numpy.mean(FactNorm) )))
             #                     #print 'GCpos',GCpos, numpy.amax(FitGauss), 'HWpos',HWpos
             #                     '''****** Getting Fij ******'''
             #
             #                     GaussCenter=xFrec[GCpos]
             #                     if (GaussCenter<0 and HalfWidth>0) or (GaussCenter>0 and HalfWidth<0):
             #                         Fij=abs(GaussCenter)+abs(HalfWidth)+0.0000001
             #                     else:
             #                         Fij=abs(GaussCenter-HalfWidth)+0.0000001
             #
             #                     '''****** Getting Frecuency range of significant data ******'''
             #
             #                     Rangpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.10)))
             #
             #                     if Rangpos<GCpos:
             #                         Range=numpy.array([Rangpos,2*GCpos-Rangpos])
             #                     else:
             #                         Range=numpy.array([2*GCpos-Rangpos,Rangpos])
             #
             #                     FrecRange=xFrec[Range[0]:Range[1]]
             #
             #                     #print 'FrecRange', FrecRange
             #                     '''****** Getting SCPC Slope ******'''
             #
             #                     for i in range(self.nRdPairs):
             #
             #                         if len(FrecRange)>5 and len(FrecRange)<self.nProfiles*0.5:
             #                             PhaseRange=moving_average(phase[i,Range[0]:Range[1]],N=3)
             #
             #                             slope, intercept, r_value, p_value, std_err = stats.linregress(FrecRange,PhaseRange)
             #                             PhaseSlope[i]=slope
             #                             PhaseInter[i]=intercept
             #                         else:
             #                             PhaseSlope[i]=0
             #                             PhaseInter[i]=0
             #
             #         #                     plt.figure(i+15)
             #         #                     plt.title('FASE ( CH%s*CH%s )' %(self.dataOut.pairsList[i][0],self.dataOut.pairsList[i][1]))
             #         #                     plt.xlabel('Frecuencia (KHz)')
             #         #                     plt.ylabel('Magnitud')
             #         #                     #plt.subplot(311+i)
             #         #                     plt.plot(FrecRange,PhaseRange,'b')
             #         #                     plt.plot(FrecRange,FrecRange*PhaseSlope[i]+PhaseInter[i],'r')
             #
             #                         #plt.axis([-0.6, 0.2, -3.2, 3.2])
             #
             #
             #                     '''Getting constant C'''
             #                     cC=(Fij*numpy.pi)**2
             #
             # #                     '''Getting Eij and Nij'''
             # #                     (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
             # #                     (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
             # #                     (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
             # #
             # #                     E01=AntennaX0-AntennaX1
             # #                     N01=AntennaY0-AntennaY1
             # #
             # #                     E02=AntennaX0-AntennaX2
             # #                     N02=AntennaY0-AntennaY2
             # #
             # #                     E12=AntennaX1-AntennaX2
             # #                     N12=AntennaY1-AntennaY2
             #
             #                     '''****** Getting constants F and G ******'''
             #                     MijEijNij=numpy.array([[E02,N02], [E12,N12]])
             #                     MijResult0=(-PhaseSlope[1]*cC) / (2*numpy.pi)
             #                     MijResult1=(-PhaseSlope[2]*cC) / (2*numpy.pi)
             #                     MijResults=numpy.array([MijResult0,MijResult1])
             #                     (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
             #
             #                     '''****** Getting constants A, B and H ******'''
             #                     W01=numpy.amax(coherence[0])
             #                     W02=numpy.amax(coherence[1])
             #                     W12=numpy.amax(coherence[2])
             #
             #                     WijResult0=((cF*E01+cG*N01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi/cC))
             #                     WijResult1=((cF*E02+cG*N02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi/cC))
             #                     WijResult2=((cF*E12+cG*N12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi/cC))
             #
             #                     WijResults=numpy.array([WijResult0, WijResult1, WijResult2])
             #
             #                     WijEijNij=numpy.array([ [E01**2, N01**2, 2*E01*N01] , [E02**2, N02**2, 2*E02*N02] , [E12**2, N12**2, 2*E12*N12] ])
             #                     (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
             #
             #                     VxVy=numpy.array([[cA,cH],[cH,cB]])
             #
             #                     VxVyResults=numpy.array([-cF,-cG])
             #                     (Vx,Vy) = numpy.linalg.solve(VxVy, VxVyResults)
             #                     Vzon = Vy
             #                     Vmer = Vx
             #                     Vmag=numpy.sqrt(Vzon**2+Vmer**2)
             #                     Vang=numpy.arctan2(Vmer,Vzon)
             #
             #                     if abs(Vy)<100 and abs(Vy)> 0.:
             #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, Vzon) #Vmag
             #                         #print 'Vmag',Vmag
             #                     else:
             #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, NaN)
             #
             #                     if abs(Vx)<100 and abs(Vx) > 0.:
             #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, Vmer) #Vang
             #                         #print 'Vang',Vang
             #                     else:
             #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, NaN)
             #
             #                     if abs(GaussCenter)<2:
             #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, xFrec[Vpos])
             #
             #                     else:
             #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, NaN)
             #
             #
             # #                 print '********************************************'
             # #                 print 'HalfWidth    ', HalfWidth
             # #                 print 'Maximun      ', Maximun
             # #                 print 'eMinus1      ', eMinus1
             # #                 print 'Rangpos      ', Rangpos
             # #                 print 'GaussCenter  ',GaussCenter
             # #                 print 'E01          ',E01
             # #                 print 'N01          ',N01
             # #                 print 'E02          ',E02
             # #                 print 'N02          ',N02
             # #                 print 'E12          ',E12
             # #                 print 'N12          ',N12
             #                 #print 'self.dataOut.velocityX          ', self.dataOut.velocityX
             # #                 print 'Fij          ', Fij
             # #                 print 'cC           ', cC
             # #                 print 'cF           ', cF
             # #                 print 'cG           ', cG
             # #                 print 'cA           ', cA
             # #                 print 'cB           ', cB
             # #                 print 'cH           ', cH
             # #                 print 'Vx           ', Vx
             # #                 print 'Vy           ', Vy
             # #                 print 'Vmag         ', Vmag
             # #                 print 'Vang         ', Vang*180/numpy.pi
             # #                 print 'PhaseSlope   ',PhaseSlope[0]
             # #                 print 'PhaseSlope   ',PhaseSlope[1]
             # #                 print 'PhaseSlope   ',PhaseSlope[2]
             # #                 print '********************************************'
             #                 #print 'data_output',shape(self.dataOut.velocityX), shape(self.dataOut.velocityY)
             #
             #                 #print 'self.dataOut.velocityX', len(self.dataOut.velocityX)
             #                 #print 'self.dataOut.velocityY', len(self.dataOut.velocityY)
             #                 #print 'self.dataOut.velocityV', self.dataOut.velocityV
             #
             #                 self.data_output[0]=numpy.array(self.dataOut.velocityX)
             #                 self.data_output[1]=numpy.array(self.dataOut.velocityY)
             #                 self.data_output[2]=numpy.array(self.dataOut.velocityV)
             #
             #                 prin= self.data_output[0][~numpy.isnan(self.data_output[0])]
             #                 print ' '
             #                 print 'VmagAverage',numpy.mean(prin)
             #                 print ' '
             # #                 plt.figure(5)
             # #                 plt.subplot(211)
             # #                 plt.plot(self.dataOut.velocityX,'yo:')
             # #                 plt.subplot(212)
             # #                 plt.plot(self.dataOut.velocityY,'yo:')
             #
             # #                 plt.figure(1)
             # # #                 plt.subplot(121)
             # # #                plt.plot(xFrec,ySamples[0],'k',label='Ch0')
             # # #                 plt.plot(xFrec,ySamples[1],'g',label='Ch1')
             # # #                 plt.plot(xFrec,ySamples[2],'r',label='Ch2')
             # # #                 plt.plot(xFrec,FitGauss,'yo:',label='fit')
             # # #                 plt.legend()
             # #                 plt.title('DATOS A ALTURA DE 2850 METROS')
             # #
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # # #                 plt.subplot(122)
             # # #                 plt.title('Fit for Time Constant')
             # #                 #plt.plot(xFrec,zline)
             # #                 #plt.plot(xFrec,SmoothSPC,'g')
             # #                 plt.plot(xFrec,FactNorm)
             # #                 plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # #
             # #                 plt.figure(10)
             # # #                 plt.subplot(121)
             # #                 plt.plot(xFrec,ySamples[0],'b',label='Ch0')
             # #                 plt.plot(xFrec,ySamples[1],'y',label='Ch1')
             # #                 plt.plot(xFrec,ySamples[2],'r',label='Ch2')
             # # #                plt.plot(xFrec,FitGauss,'yo:',label='fit')
             # #                 plt.legend()
             # #                 plt.title('SELFSPECTRA EN CANALES')
             # #
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # # #                 plt.subplot(122)
             # # #                 plt.title('Fit for Time Constant')
             # #                 #plt.plot(xFrec,zline)
             # #                 #plt.plot(xFrec,SmoothSPC,'g')
             # # #                plt.plot(xFrec,FactNorm)
             # # #                plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # #
             # #                 plt.figure(9)
             # #
             # #
             # #                 plt.title('DATOS SUAVIZADOS')
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # #                 plt.plot(xFrec,SmoothSPC,'g')
             # #
             # #                 #plt.plot(xFrec,FactNorm)
             # #                 plt.axis([-4, 4, 0, 0.15])
             # # #                 plt.xlabel('SelfSpectra KHz')
             # # #
             # #                 plt.figure(2)
             # # #                 #plt.subplot(121)
             # #                 plt.plot(xFrec,yMean,'r',label='Mean SelfSpectra')
             # #                 plt.plot(xFrec,FitGauss,'yo:',label='Ajuste Gaussiano')
             # # #                 plt.plot(xFrec[Rangpos],FitGauss[Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.1)))],'bo')
             # # #                 #plt.plot(xFrec,phase)
             # # #                 plt.xlabel('Suavizado, promediado KHz')
             # #                 plt.title('SELFSPECTRA PROMEDIADO')
             # # #                 #plt.subplot(122)
             # # #                 #plt.plot(xSamples,zline)
             # #                 plt.xlabel('Frecuencia (KHz)')
             # #                 plt.ylabel('Magnitud')
             # #                 plt.legend()
             # # #
             # # #                 plt.figure(3)
             # # #                 plt.subplot(311)
             # # #                 #plt.plot(xFrec,phase[0])
             # # #                 plt.plot(xFrec,phase[0],'g')
             # # #                 plt.subplot(312)
             # # #                 plt.plot(xFrec,phase[1],'g')
             # # #                 plt.subplot(313)
             # # #                 plt.plot(xFrec,phase[2],'g')
             # # #                 #plt.plot(xFrec,phase[2])
             # # #
             # # #                 plt.figure(4)
             # # #
             # # #                 plt.plot(xSamples,coherence[0],'b')
             # # #                 plt.plot(xSamples,coherence[1],'r')
             # # #                 plt.plot(xSamples,coherence[2],'g')
             # #                 plt.show()
             # # #
             # # #                 plt.clf()
             # # #                 plt.cla()
             # # #                 plt.close()
             #
             #                 print ' '
                         self.BlockCounter+=2
                     else:
                         self.fileSelector+=1
                         self.BlockCounter=0
                         print "Next File"
             class BLTRWriter(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.dataOut = None
                     self.isConfig = False
                 def setup(self, dataIn, path, blocksPerFile, set=0, ext=None):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataIn        :        Input data will also be outputa data
                     '''
                     self.dataOut = dataIn
                     self.isConfig = True
                     return
                 def run(self, dataIn, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataIn        :        object with the data
                     '''
                     if not self.isConfig:
                         self.setup(dataIn, **kwargs)

schainpy/model/io/jroIO_bltr.pyc binary modified 0 0

NO CONTENT: modified file, binary diff hidden

schainpy/model/proc/jroproc_bltr.pyc binary modified 0 0

NO CONTENT: modified file, binary diff hidden

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/model/proc/jroproc_parameters.pyc binary modified 0 0

NO CONTENT: modified file, binary diff hidden

schainpy/scripts/schain.xml +1 -1

	@@ -1,1 +1,1
	1	<Project description="read bltr data sswma file" id="191" name="test1"><ReadUnit datatype="testBLTRReader" id="1911" inputId="0" name="testBLTRReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="testBLTRReader" /><Parameter format="str" id="191112" name="path" value="/media/erick/6F60F7113095A154/BLTR" /><Parameter format="date" id="191113" name="startDate" value="2017/01/17" /><Parameter format="date" id="191114" name="endDate" value="2018/01/01" /><Parameter format="time" id="191115" name="startTime" value="00:00:00" /><Parameter format="time" id="191116" name="endTime" value="23:59:59" /><Parameter format="str" id="191118" name="ext" value="sswma" /></Operation></ReadUnit><ProcUnit datatype="BLTRProcess" id="1912" inputId="1911" name="BLTRProcess"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="SnrFilter" priority="2" type="self"><Parameter format="float" id="191221" name="snr_val" value="-20" /><Parameter format="int" id="191222" name="modetofilter" value="2" /></Operation><Operation id="19123" name="OutliersFilter" priority="3" type="self"><Parameter format="str" id="191231" name="svalue" value="meridional" /><Parameter format="str" id="191232" name="svalue2" value="inTime" /><Parameter format="float" id="191233" name="method" value="0" /><Parameter format="float" id="191234" name="factor" value="2" /><Parameter format="float" id="191235" name="filter" value="0" /><Parameter format="float" id="191236" name="npoints" value="9" /><Parameter format="int" id="191237" name="modetofilter" value="2" /></Operation><Operation id="19124" name="OutliersFilter" priority="4" type="self"><Parameter format="str" id="191241" name="svalue" value="zonal" /><Parameter format="str" id="191242" name="svalue2" value="inTime" /><Parameter format="float" id="191243" name="method" value="0" /><Parameter format="float" id="191244" name="factor" value="2" /><Parameter format="float" id="191245" name="filter" value="0" /><Parameter format="float" id="191246" name="npoints" value="9" /><Parameter format="int" id="191247" name="modetofilter" value="2" /></Operation><Operation id="19125" name="OutliersFilter" priority="5" type="self"><Parameter format="str" id="191251" name="svalue" value="vertical" /><Parameter format="str" id="191252" name="svalue2" value="inHeight" /><Parameter format="float" id="191253" name="method" value="0" /><Parameter format="float" id="191254" name="factor" value="2" /><Parameter format="float" id="191255" name="filter" value="0" /><Parameter format="float" id="191256" name="npoints" value="9" /><Parameter format="int" id="191257" name="modetofilter" value="2" /></Operation><Operation id="19126" name="prePlot" priority="6" type="self"><Parameter format="int" id="191261" name="modeselect" value="1" /></Operation><Operation id="19127" name="WindProfilerPlot" priority="7" type="other"><Parameter format="int" id="191271" name="id" value="1" /><Parameter format="str" id="191272" name="wintitle" value="" /><Parameter format="intlist" id="191273" name="channelList" value="0" /><Parameter format="int" id="191274" name="SNRmin" value="-10" /><Parameter format="int" id="191275" name="SNRmax" value="50" /><Parameter format="float" id="191276" name="SNRthresh" value="0" /><Parameter format="float" id="191277" name="xmin" value="0" /><Parameter format="float" id="191278" name="xmax" value="24" /><Parameter format="float" id="191279" name="ymax" value="3" /><Parameter format="float" id="191280" name="zmin" value="-20" /><Parameter format="float" id="191281" name="zmax" value="20" /><Parameter format="float" id="191282" name="zmin_ver" value="-200" /><Parameter format="float" id="191283" name="zmax_ver" value="200" /></Operation><Operation id="19128" name="prePlot" priority="8" type="self"><Parameter format="int" id="191281" name="modeselect" value="2" /></Operation><Operation id="19129" name="WindProfilerPlot" priority="9" type="other"><Parameter format="int" id="191291" name="id" value="2" /><Parameter format="str" id="191292" name="wintitle" value="" /><Parameter format="bool" id="191293" name="save" value="1" /><Parameter format="str" id="191294" name="figpath" value="/media/erick/6F60F7113095A154/BLTR/" /><Parameter format="int" id="191295" name="SNRmin" value="-20" /><Parameter format="int" id="191296" name="SNRmax" value="40" /><Parameter format="float" id="191297" name="SNRthresh" value="0" /><Parameter format="float" id="191298" name="xmin" value="0" /><Parameter format="float" id="191299" name="xmax" value="24" /><Parameter format="float" id="191300" name="ymin" value="0" /><Parameter format="float" id="191301" name="ymax" value="10" /><Parameter format="float" id="191302" name="zmin" value="-4" /><Parameter format="float" id="191303" name="zmax" value="4" /><Parameter format="float" id="191304" name="zmin_ver" value="-200" /><Parameter format="float" id="191305" name="zmax_ver" value="200" /></Operation></ProcUnit></Project> No newline at end of file		1	<Project description="Segundo Test" id="191" name="test01"><ReadUnit datatype="VoltageReader" id="1911" inputId="0" name="VoltageReader"><Operation id="19111" name="run" priority="1" type="self"><Parameter format="str" id="191111" name="datatype" value="VoltageReader" /><Parameter format="str" id="191112" name="path" value="/home/erick/Documents/Data/Claire_Data/raw" /><Parameter format="date" id="191113" name="startDate" value="2017/07/26" /><Parameter format="date" id="191114" name="endDate" value="2017/07/26" /><Parameter format="time" id="191115" name="startTime" value="10:02:00" /><Parameter format="time" id="191116" name="endTime" value="10:11:00" /><Parameter format="int" id="191118" name="online" value="0" /><Parameter format="int" id="191119" name="walk" value="1" /></Operation><Operation id="19112" name="printNumberOfBlock" priority="2" type="self" /></ReadUnit><ProcUnit datatype="SpectraProc" id="1913" inputId="1912" name="SpectraProc"><Operation id="19131" name="run" priority="1" type="self"><Parameter format="int" id="191311" name="nFFTPoints" value="128" /><Parameter format="pairslist" id="191312" name="pairsList" value="(0,1),(0,2),(1,2)" /></Operation><Operation id="19132" name="removeDC" priority="2" type="self" /><Operation id="19133" name="IncohInt" priority="3" type="external"><Parameter format="float" id="191331" name="n" value="30" /></Operation><Operation id="19134" name="CrossSpectraPlot" priority="4" type="other"><Parameter format="str" id="191341" name="phase_cmap" value="bwr" /><Parameter format="int" id="191342" name="id" value="2005" /><Parameter format="str" id="191343" name="wintitle" value="CrossSpectraPlot_ShortPulse" /><Parameter format="str" id="191344" name="xaxis" value="Velocity" /><Parameter format="float" id="191345" name="ymin" value="1" /><Parameter format="int" id="191346" name="ymax" value="7" /><Parameter format="int" id="191347" name="zmin" value="15" /><Parameter format="int" id="191348" name="zmax" value="60" /><Parameter format="int" id="191349" name="save" value="2" /><Parameter format="str" id="191350" name="figpath" value="/media/erick/6F60F7113095A154/CLAIRE/CLAIRE_WINDS_2MHZ/Images" /></Operation></ProcUnit><ProcUnit datatype="VoltageProc" id="1912" inputId="1911" name="VoltageProc"><Operation id="19121" name="run" priority="1" type="self" /><Operation id="19122" name="setRadarFrequency" priority="2" type="self"><Parameter format="float" id="191221" name="frequency" value="445.09e6" /></Operation><Operation id="19123" name="selectHeights" priority="3" type="self"><Parameter format="float" id="191231" name="minHei" value="0" /><Parameter format="float" id="191232" name="maxHei" value="64" /></Operation></ProcUnit><ProcUnit datatype="Parameters" id="1914" inputId="1913" name="ParametersProc"><Operation id="19141" name="run" priority="1" type="self" /><Operation id="19142" name="GaussianFit" priority="2" type="other" /></ProcUnit></Project> No newline at end of file

schainpy/scripts/testBLTR_block.py +1 -1

             '''
             Created on Nov 09, 2016
             @author: roj- LouVD
             '''
             import os, sys
             path = os.path.split(os.getcwd())[0]
             path = os.path.split(path)[0]
             sys.path.insert(0, path)
             from schainpy.controller import Project
             filename = 'test1.xml'
             # path = '/home/jespinoza/workspace/data/bltr/'
             path = '/media/erick/6F60F7113095A154/BLTR/'
             desc = "read bltr data sswma file"
             figpath = '/media/erick/6F60F7113095A154/BLTR/'
             pathhdf5 = '/tmp/'
             controllerObj = Project()
             controllerObj.setup(id = '191', name='test1', description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='testBLTRReader',
                                                         path=path,
                                                         startDate='2017/01/17',
                                                         endDate='2018/01/01',
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         ext='sswma')
             procUnitConfObj1 = controllerObj.addProcUnit(datatype='BLTRProcess',
                                                          inputId=readUnitConfObj.getId())
             '''-------------------------------------------Processing--------------------------------------------'''
             '''MODE 1: LOW ATMOSPHERE: 0- 3 km'''
             # opObj10 = procUnitConfObj1.addOperation(name='SnrFilter')
             # opObj10.addParameter(name='snr_val', value='-10', format='float')
             # opObj10.addParameter(name='modetofilter', value='1', format='int')
             #
             # opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             # opObj10.addParameter(name='svalue', value='meridional', format='str')
             # opObj10.addParameter(name='svalue2', value='inTime', format='str')
             # opObj10.addParameter(name='method', value='0', format='float')
             # opObj10.addParameter(name='factor', value='1', format='float')
             # opObj10.addParameter(name='filter', value='0', format='float')
             # opObj10.addParameter(name='npoints', value='5', format='float')
             # opObj10.addParameter(name='modetofilter', value='1', format='int')
             # #
             # opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             # opObj10.addParameter(name='svalue', value='zonal', format='str')
             # opObj10.addParameter(name='svalue2', value='inTime', format='str')
             # opObj10.addParameter(name='method', value='0', format='float')
             # opObj10.addParameter(name='factor', value='1', format='float')
             # opObj10.addParameter(name='filter', value='0', format='float')
             # opObj10.addParameter(name='npoints', value='5', format='float')
             # opObj10.addParameter(name='modetofilter', value='1', format='int')
             # #
             # opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             # opObj10.addParameter(name='svalue', value='vertical', format='str')
             # opObj10.addParameter(name='svalue2', value='inHeight', format='str')
             # opObj10.addParameter(name='method', value='0', format='float')
             # opObj10.addParameter(name='factor', value='2', format='float')
             # opObj10.addParameter(name='filter', value='0', format='float')
             # opObj10.addParameter(name='npoints', value='9', format='float')
             # opObj10.addParameter(name='modetofilter', value='1', format='int')
             #
             ''' MODE 2: 0 - 10 km '''
             opObj10 = procUnitConfObj1.addOperation(name='SnrFilter')
             opObj10.addParameter(name='snr_val', value='-20', format='float')
             opObj10.addParameter(name='modetofilter', value='2', format='int')
             opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             opObj10.addParameter(name='svalue', value='meridional', format='str')
             opObj10.addParameter(name='svalue2', value='inTime', format='str')
             opObj10.addParameter(name='method', value='0', format='float')
             opObj10.addParameter(name='factor', value='2', format='float')
             opObj10.addParameter(name='filter', value='0', format='float')
             opObj10.addParameter(name='npoints', value='9', format='float')
             opObj10.addParameter(name='modetofilter', value='2', format='int')
             # #
             opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             opObj10.addParameter(name='svalue', value='zonal', format='str')
             opObj10.addParameter(name='svalue2', value='inTime', format='str')
             opObj10.addParameter(name='method', value='0', format='float')
             opObj10.addParameter(name='factor', value='2', format='float')
             opObj10.addParameter(name='filter', value='0', format='float')
             opObj10.addParameter(name='npoints', value='9', format='float')
             opObj10.addParameter(name='modetofilter', value='2', format='int')
             # #
             opObj10 = procUnitConfObj1.addOperation(name='OutliersFilter')
             opObj10.addParameter(name='svalue', value='vertical', format='str')
             opObj10.addParameter(name='svalue2', value='inHeight', format='str')
             opObj10.addParameter(name='method', value='0', format='float')
             opObj10.addParameter(name='factor', value='2', format='float')
             opObj10.addParameter(name='filter', value='0', format='float')
             opObj10.addParameter(name='npoints', value='9', format='float')
             opObj10.addParameter(name='modetofilter', value='2', format='int')
             # '''-----------------------------------------Writing-------------------------------------------'''
             #
             # # opObj10 =  procUnitConfObj1.addOperation(name='testBLTRWriter',optype='other')
             # # opObj10.addParameter(name='path', value = pathhdf5)
             # # opObj10.addParameter(name='modetowrite', value = '2',format='int')
             # #
             # # opObj10 =  procUnitConfObj1.addOperation(name='testBLTRWriter',optype='other')
             # # opObj10.addParameter(name='path', value = pathhdf5)
             # # opObj10.addParameter(name='modetowrite', value = '1',format='int')
             #
             # '''----------------------------------------Plotting--------------------------------------------'''
             #
             opObj10 = procUnitConfObj1.addOperation(name='prePlot')
             opObj10.addParameter(name='modeselect',value='1',format='int')
             # #
             opObj10 = procUnitConfObj1.addOperation(name='WindProfilerPlot', optype='other')
             opObj10.addParameter(name='id', value='1', format='int')
             opObj10.addParameter(name='wintitle', value='', format='str')
             opObj10.addParameter(name='channelList', value='0', format='intlist')
             #opObj10.addParameter(name='save', value='1', format='bool')
             #opObj10.addParameter(name='figpath', value=figpath, format='str')
             opObj10.addParameter(name='SNRmin', value='-10', format='int')
             opObj10.addParameter(name='SNRmax', value='50', format='int')
             opObj10.addParameter(name='SNRthresh', value='0', format='float')
             opObj10.addParameter(name='xmin', value='0', format='float')
             opObj10.addParameter(name='xmax', value='24', format='float')
             opObj10.addParameter(name='ymax', value='3', format='float')
             opObj10.addParameter(name='zmin', value='-20', format='float')
             opObj10.addParameter(name='zmax', value='20', format='float')
             opObj10.addParameter(name='zmin_ver', value='-200', format='float')
             opObj10.addParameter(name='zmax_ver', value='200', format='float')
             #opObj10.addParameter(name='showprofile', value='1', format='bool')
             #opObj10.addParameter(name='show', value='1', format='bool')
             opObj10 = procUnitConfObj1.addOperation(name='prePlot')
             opObj10.addParameter(name='modeselect',value='2',format='int')
             #
             opObj10 = procUnitConfObj1.addOperation(name='WindProfilerPlot', optype='other')
             opObj10.addParameter(name='id', value='2', format='int')
             opObj10.addParameter(name='wintitle', value='', format='str')
             #opObj10.addParameter(name='channelList', value='0', format='intlist')
             opObj10.addParameter(name='save', value='1', format='bool')
             opObj10.addParameter(name='figpath', value=figpath, format='str')
             opObj10.addParameter(name='SNRmin', value='-20', format='int')
             opObj10.addParameter(name='SNRmax', value='40', format='int')
             opObj10.addParameter(name='SNRthresh', value='0', format='float')
             opObj10.addParameter(name='xmin', value='0', format='float')
             opObj10.addParameter(name='xmax', value='24', format='float')
             opObj10.addParameter(name='ymin', value='0', format='float')
-            opObj10.addParameter(name='ymax', value='10', format='float')
+            opObj10.addParameter(name='ymax', value='7', format='float')
             opObj10.addParameter(name='zmin', value='-4', format='float')
             opObj10.addParameter(name='zmax', value='4', format='float')
             opObj10.addParameter(name='zmin_ver', value='-200', format='float')
             opObj10.addParameter(name='zmax_ver', value='200', format='float')
             #opObj10.addParameter(name='showprofile', value='1', format='bool')
             #opObj10.addParameter(name='show', value='1', format='bool')
             # # print "Escribiendo el archivo XML"
             # controllerObj.writeXml(filename)
             # # print "Leyendo el archivo XML"
             # controllerObj.readXml(filename)
             # controllerObj.createObjects()
             # controllerObj.connectObjects()
             # controllerObj.run()
             controllerObj.start()

schainpy/scripts/testProcBLTR.py +3 -2

             #!/usr/bin/env python
             import os, sys
             # path = os.path.dirname(os.getcwd())
             # path = os.path.join(path, 'source')
             # sys.path.insert(0, '../')
             from schainpy.controller import Project
             xmin = '15.5'
             xmax = '24'
             desc = "ProcBLTR Test"
             filename = "ProcBLTR.xml"
             figpath = '/media/erick/6F60F7113095A154/BLTR'
             controllerObj = Project()
             controllerObj.setup(id='191', name='test01', description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='BLTRReader',
                                                             path='/media/erick/6F60F7113095A154/BLTR/',
                                                             endDate='2017/10/19',
                                                             startTime='13:00:00',
                                                             startDate='2016/11/8',
                                                             endTime='23:59:59',
                                                             online=0,
                                                             walk=0,
                                                             ReadMode='1')
                                                             # expLabel='')
             # opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
             procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=readUnitConfObj.getId())
             opObj11 = procUnitConfObj1.addOperation(name='IncohInt', optype='other')
             opObj11.addParameter(name='n', value='3', format='float')
             opObj10 = procUnitConfObj1.addOperation(name='removeDC')
             # opObj10 = procUnitConfObj1.addOperation(name='calcMag')
             # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='other')
             # opObj11.addParameter(name='id', value='21', format='int')
             # opObj11.addParameter(name='wintitle', value='SpectraCutPlot', format='str')
             # opObj11.addParameter(name='xaxis', value='frequency', format='str')
             # opObj11.addParameter(name='colormap', value='winter', format='str')
             # opObj11.addParameter(name='xmin', value='-0.005', format='float')
             # opObj11.addParameter(name='xmax', value='0.005', format='float')
             # #opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
             # #opObj10.addParameter(name='channelList', value='0,1', format='intlist')
             # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='other')
             # opObj11.addParameter(name='id', value='21', format='int')
             # opObj11.addParameter(name='wintitle', value='SpectraPlot', format='str')
             # #opObj11.addParameter(name='xaxis', value='Velocity', format='str')
             # opObj11.addParameter(name='xaxis', value='velocity', format='str')
             # opObj11.addParameter(name='xmin', value='-0.005', format='float')
             # opObj11.addParameter(name='xmax', value='0.005', format='float')
             # opObj11.addParameter(name='ymin', value='225', format='float')
             # opObj11.addParameter(name='ymax', value='3000', format='float')
             # opObj11.addParameter(name='zmin', value='-100', format='int')
             # opObj11.addParameter(name='zmax', value='-65', format='int')
             # opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='other')
             # opObj11.addParameter(name='id', value='10', format='int')
             # opObj11.addParameter(name='wintitle', value='RTI', format='str')
              # opObj11.addParameter(name='ymin', value='0', format='float')
              # opObj11.addParameter(name='ymax', value='4000', format='float')
             # #opObj11.addParameter(name='zmin', value='-100', format='int')
             # #opObj11.addParameter(name='zmax', value='-70', format='int')
              # opObj11.addParameter(name='zmin', value='-90', format='int')
              # opObj11.addParameter(name='zmax', value='-40', format='int')
             # opObj11.addParameter(name='showprofile', value='1', format='int')
             # opObj11.addParameter(name='timerange', value=str(2*60*60), format='int')
             opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='other')
             procUnitConfObj1.addParameter(name='pairsList', value='(0,1),(0,2),(1,2)', format='pairsList')
             opObj11.addParameter(name='id', value='2005', format='int')
             opObj11.addParameter(name='wintitle', value='CrossSpectraPlot_ShortPulse', format='str')
             # opObj11.addParameter(name='exp_code', value='13', format='int')
             opObj11.addParameter(name='xaxis', value='Velocity', format='str')
             #opObj11.addParameter(name='xmin', value='-10', format='float')
             #opObj11.addParameter(name='xmax', value='10', format='float')
             #opObj11.addParameter(name='ymin', value='225', format='float')
             #opObj11.addParameter(name='ymax', value='3000', format='float')
             #opObj11.addParameter(name='phase_min', value='-4', format='int')
             #opObj11.addParameter(name='phase_max', value='4', format='int')
             # procUnitConfObj2 = controllerObj.addProcUnit(datatype='CorrelationProc', inputId=procUnitConfObj1.getId())
             # procUnitConfObj2.addParameter(name='pairsList', value='(0,1),(0,2),(1,2)', format='pairsList')
             procUnitConfObj2 = controllerObj.addProcUnit(datatype='Parameters', inputId=procUnitConfObj1.getId())
             opObj11 = procUnitConfObj2.addOperation(name='SpectralMoments', optype='other')
             opObj22 = procUnitConfObj2.addOperation(name='FullSpectralAnalysis', optype='other')
+            opObj22.addParameter(name='SNRlimit', value='-4', format='float')
             #
             opObj22 = procUnitConfObj2.addOperation(name='WindProfilerPlot', optype='other')
             opObj22.addParameter(name='id', value='4', format='int')
             opObj22.addParameter(name='wintitle', value='Wind Profiler', format='str')
             opObj22.addParameter(name='save', value='1', format='bool')
             # opObj22.addParameter(name='figpath', value = '/home/erick/Pictures', format='str')
             opObj22.addParameter(name='zmin', value='-20', format='int')
             opObj22.addParameter(name='zmax', value='20', format='int')
             opObj22.addParameter(name='zmin_ver', value='-250', format='float')
             opObj22.addParameter(name='zmax_ver', value='250', format='float')
             opObj22.addParameter(name='SNRmin', value='-5', format='int')
             opObj22.addParameter(name='SNRmax', value='30', format='int')
             # opObj22.addParameter(name='SNRthresh', value='-3.5', format='float')
-            opObj22.addParameter(name='xmin', value=0, format='float')
+            opObj22.addParameter(name='xmin', value='0', format='float')
-            opObj22.addParameter(name='xmax', value=24, format='float')
+            opObj22.addParameter(name='xmax', value='24', format='float')
             opObj22.addParameter(name='ymin', value='225', format='float')
             #opObj22.addParameter(name='ymax', value='2000', format='float')
             opObj22.addParameter(name='save', value='1', format='int')
             opObj22.addParameter(name='figpath', value=figpath, format='str')
             # opObj11.addParameter(name='pairlist', value='(1,0),(0,2),(1,2)', format='pairsList')
             #opObj10 = procUnitConfObj1.addOperation(name='selectHeights')
             #opObj10.addParameter(name='minHei', value='225', format='float')
             #opObj10.addParameter(name='maxHei', value='1000', format='float')
             # opObj11 = procUnitConfObj1.addOperation(name='CoherenceMap', optype='other')
             # opObj11.addParameter(name='id', value='102', format='int')
             # opObj11.addParameter(name='wintitle', value='Coherence', format='str')
             # opObj11.addParameter(name='ymin', value='225', format='float')
             # opObj11.addParameter(name='ymax', value='4000', format='float')
             # opObj11.addParameter(name='phase_cmap', value='jet', format='str')
             # opObj11.addParameter(name='xmin', value='8.5', format='float')
             # opObj11.addParameter(name='xmax', value='9.5', format='float')
             # opObj11.addParameter(name='figpath', value=figpath, format='str')
             # opObj11.addParameter(name='save', value=1, format='bool')
             # opObj11.addParameter(name='pairsList', value='(1,0),(3,2)', format='pairsList')
             # opObj12 = procUnitConfObj1.addOperation(name='PublishData', optype='other')
             # opObj12.addParameter(name='zeromq', value=1, format='int')
             # opObj12.addParameter(name='verbose', value=0, format='bool')
             # opObj12.addParameter(name='server', value='erick2', format='str')
             controllerObj.start()

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