schain Commit - r1027:f11c2da27e74 · Jicamarca Repository

07/09/2017

ebocanegra -

r1027:f11c2da27e74

parent child

Context file:

r1027:f11c2da27e74

Collapse all files

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 +44 -37

             import numpy
             import math
             from scipy import optimize, interpolate, signal, stats, ndimage
             import scipy
             import re
             import datetime
             import copy
             import sys
             import importlib
             import itertools
             from multiprocessing import Pool, TimeoutError
             from multiprocessing.pool import ThreadPool
             import copy_reg
             import cPickle
             import types
             from functools import partial
             import time
             #from sklearn.cluster import KMeans
             import matplotlib.pyplot as plt
             from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
             from jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Parameters, hildebrand_sekhon
             from scipy import asarray as ar,exp
             from scipy.optimize import curve_fit
             import warnings
             from numpy import NaN
             from scipy.optimize.optimize import OptimizeWarning
             warnings.filterwarnings('ignore')
             SPEED_OF_LIGHT = 299792458
             '''solving pickling issue'''
             def _pickle_method(method):
                 func_name = method.im_func.__name__
                 obj = method.im_self
                 cls = method.im_class
                 return _unpickle_method, (func_name, obj, cls)
             def _unpickle_method(func_name, obj, cls):
                 for cls in cls.mro():
                     try:
                         func = cls.__dict__[func_name]
                     except KeyError:
                         pass
                     else:
                         break
                 return func.__get__(obj, cls)
             class ParametersProc(ProcessingUnit):
                 nSeconds = None
                 def __init__(self):
                     ProcessingUnit.__init__(self)
             #         self.objectDict = {}
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Parameters()
                 def __updateObjFromInput(self):
                     self.dataOut.inputUnit = self.dataIn.type
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
             #         self.dataOut.nHeights = self.dataIn.nHeights
             #         self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
             #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
             #         self.dataOut.utctime = self.firstdatatime
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.nCohInt = self.dataIn.nCohInt
             #        self.dataOut.nIncohInt = 1
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
             #        self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.timeInterval1 = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.getHeiRange()
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.noise = self.dataIn.noise
                 def run(self):
                     #----------------------    Voltage Data    ---------------------------
                     if self.dataIn.type == "Voltage":
                         self.__updateObjFromInput()
                         self.dataOut.data_pre = self.dataIn.data.copy()
                         self.dataOut.flagNoData = False
                         self.dataOut.utctimeInit = self.dataIn.utctime
                         self.dataOut.paramInterval = self.dataIn.nProfiles*self.dataIn.nCohInt*self.dataIn.ippSeconds
                         return
                     #----------------------    Spectra Data    ---------------------------
                     if self.dataIn.type == "Spectra":
                         self.dataOut.data_pre = (self.dataIn.data_spc,self.dataIn.data_cspc)
                         print 'self.dataIn.data_spc', self.dataIn.data_spc.shape
                         self.dataOut.abscissaList = self.dataIn.getVelRange(1)
                         self.dataOut.spc_noise = self.dataIn.getNoise()
                         self.dataOut.spc_range = (self.dataIn.getFreqRange(1)/1000. , self.dataIn.getAcfRange(1) , self.dataIn.getVelRange(1) )
                         self.dataOut.normFactor = self.dataIn.normFactor
                         #self.dataOut.outputInterval = self.dataIn.outputInterval
                         self.dataOut.groupList = self.dataIn.pairsList
                         self.dataOut.flagNoData = False
                         #print 'datain chandist ',self.dataIn.ChanDist
                         if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels
                             self.dataOut.ChanDist = self.dataIn.ChanDist
                         else: self.dataOut.ChanDist = None
                         print 'datain chandist ',self.dataOut.ChanDist
                         if hasattr(self.dataIn, 'VelRange'): #Velocities range
                             self.dataOut.VelRange = self.dataIn.VelRange
                         else: self.dataOut.VelRange = None
                         if hasattr(self.dataIn, 'RadarConst'): #Radar Constant
                             self.dataOut.RadarConst = self.dataIn.RadarConst
                         if hasattr(self.dataIn, 'NPW'): #NPW
                             self.dataOut.NPW = self.dataIn.NPW
                         if hasattr(self.dataIn, 'COFA'): #COFA
                             self.dataOut.COFA = self.dataIn.COFA
                     #----------------------    Correlation Data    ---------------------------
                     if self.dataIn.type == "Correlation":
                         acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.dataIn.splitFunctions()
                         self.dataOut.data_pre = (self.dataIn.data_cf[acf_ind,:], self.dataIn.data_cf[ccf_ind,:,:])
                         self.dataOut.normFactor = (self.dataIn.normFactor[acf_ind,:], self.dataIn.normFactor[ccf_ind,:])
                         self.dataOut.groupList = (acf_pairs, ccf_pairs)
                         self.dataOut.abscissaList = self.dataIn.lagRange
                         self.dataOut.noise = self.dataIn.noise
                         self.dataOut.data_SNR = self.dataIn.SNR
                         self.dataOut.flagNoData = False
                         self.dataOut.nAvg = self.dataIn.nAvg
                     #----------------------    Parameters Data    ---------------------------
                     if self.dataIn.type == "Parameters":
                         self.dataOut.copy(self.dataIn)
                         self.dataOut.flagNoData = False
                         return True
                     self.__updateObjFromInput()
                     self.dataOut.utctimeInit = self.dataIn.utctime
                     self.dataOut.paramInterval = self.dataIn.timeInterval
                     return
             def target(tups):
                 obj, args = tups
                 #print 'TARGETTT', obj, args
                 return obj.FitGau(args)
             class GaussianFit(Operation):
                 '''
                     Function that fit of one and two generalized gaussians (gg) based
                     on the PSD shape across an "power band" identified from a cumsum of
                     the measured spectrum - noise.
                     Input:
                         self.dataOut.data_pre    :    SelfSpectra
                     Output:
                         self.dataOut.GauSPC :    SPC_ch1, SPC_ch2
                 '''
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.i=0
                 def run(self, dataOut, num_intg=7, pnoise=1., vel_arr=None, SNRlimit=-9): #num_intg: Incoherent integrations, pnoise: Noise, vel_arr: range of velocities, similar to the ftt points
                     """This routine will find a couple of generalized Gaussians to a power spectrum
                     input: spc
                     output:
                         Amplitude0,shift0,width0,p0,Amplitude1,shift1,width1,p1,noise
                     """
                     self.spc = dataOut.data_pre[0].copy()
                     print 'SelfSpectra Shape', numpy.asarray(self.spc).shape
                     #plt.figure(50)
                     #plt.subplot(121)
                     #plt.plot(self.spc,'k',label='spc(66)')
                     #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 7500 METROS')
                     #plt.show()
                     self.Num_Hei = self.spc.shape[2]
                     #self.Num_Bin = len(self.spc)
                     self.Num_Bin = self.spc.shape[1]
                     self.Num_Chn = self.spc.shape[0]
                     Vrange = dataOut.abscissaList
                     #print 'self.spc2', numpy.asarray(self.spc).shape
                     GauSPC = numpy.empty([2,self.Num_Bin,self.Num_Hei])
                     SPC_ch1 = numpy.empty([self.Num_Bin,self.Num_Hei])
                     SPC_ch2 = numpy.empty([self.Num_Bin,self.Num_Hei])
                     SPC_ch1[:] = numpy.NaN
                     SPC_ch2[:] = numpy.NaN
                     start_time = time.time()
                     noise_ = dataOut.spc_noise[0].copy()
                     pool = Pool(processes=self.Num_Chn)
                     args = [(Vrange, Ch, pnoise, noise_, num_intg, SNRlimit) for Ch in range(self.Num_Chn)]
                     objs = [self for __ in range(self.Num_Chn)]
                     attrs = zip(objs, args)
                     gauSPC = pool.map(target, attrs)
                     dataOut.GauSPC = numpy.asarray(gauSPC)
             #         ret = []
             #         for n in range(self.Num_Chn):
             #             self.FitGau(args[n])
             #         dataOut.GauSPC = ret
             #         for ch in range(self.Num_Chn):
             #
             #             for ht in range(self.Num_Hei):
             #                 #print (numpy.asarray(self.spc).shape)
             #                 spc =  numpy.asarray(self.spc)[ch,:,ht]
             #
             #                 #############################################
             #                 # normalizing spc and noise
             #                 # This part differs from gg1
             #                 spc_norm_max = max(spc)
             #                 spc = spc / spc_norm_max
             #                 pnoise = pnoise / spc_norm_max
             #                 #############################################
             #
             #                 if abs(vel_arr[0])<15.0: # this switch is for spectra collected with different length IPP's
             #                     fatspectra=1.0
             #                 else:
             #                     fatspectra=0.5
             #
             #                 wnoise =  noise_ / spc_norm_max
             #                 #print 'wnoise', noise_, dataOut.spc_noise[0], wnoise
             #                 #wnoise,stdv,i_max,index =enoise(spc,num_intg) #noise estimate using Hildebrand Sekhon, only wnoise is used
             #                 #if wnoise>1.1*pnoise: # to be tested later
             #                 #    wnoise=pnoise
             #                 noisebl=wnoise*0.9; noisebh=wnoise*1.1
             #                 spc=spc-wnoise
             #
             #                 minx=numpy.argmin(spc)
             #                 spcs=numpy.roll(spc,-minx)
             #                 cum=numpy.cumsum(spcs)
             #                 tot_noise=wnoise * self.Num_Bin  #64;
             #                 #tot_signal=sum(cum[-5:])/5.; ''' How does this line work? '''
             #                 #snr=tot_signal/tot_noise
             #                 #snr=cum[-1]/tot_noise
             #
             #                 #print 'spc' , spcs[5:8] , 'tot_noise', tot_noise
             #
             #                 snr = sum(spcs)/tot_noise
             #                 snrdB=10.*numpy.log10(snr)
             #
             #                 #if snrdB < -9 :
             #                 #    snrdB = numpy.NaN
             #                 #    continue
             #
             #                 #print 'snr',snrdB # , sum(spcs) , tot_noise
             #
             #
             #                 #if snrdB<-18 or numpy.isnan(snrdB) or num_intg<4:
             #                 #    return [None,]*4,[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
             #
             #                 cummax=max(cum); epsi=0.08*fatspectra # cumsum to narrow down the energy region
             #                 cumlo=cummax*epsi;
             #                 cumhi=cummax*(1-epsi)
             #                 powerindex=numpy.array(numpy.where(numpy.logical_and(cum>cumlo, cum<cumhi))[0])
             #
             #                 #if len(powerindex)==1:
             #                     ##return [numpy.mod(powerindex[0]+minx,64),None,None,None,],[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
             #                     #return [numpy.mod(powerindex[0]+minx, self.Num_Bin ),None,None,None,],[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
             #                 #elif len(powerindex)<4*fatspectra:
             #                     #return [None,]*4,[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
             #
             #                 if len(powerindex) < 1:# case for powerindex 0
             #                     continue
             #                 powerlo=powerindex[0]
             #                 powerhi=powerindex[-1]
             #                 powerwidth=powerhi-powerlo
             #
             #                 firstpeak=powerlo+powerwidth/10.# first gaussian energy location
             #                 secondpeak=powerhi-powerwidth/10.#second gaussian energy location
             #                 midpeak=(firstpeak+secondpeak)/2.
             #                 firstamp=spcs[int(firstpeak)]
             #                 secondamp=spcs[int(secondpeak)]
             #                 midamp=spcs[int(midpeak)]
             #                 #x=numpy.spc.shape[1]
             #
             #                 #x=numpy.arange(64)
             #                 x=numpy.arange( self.Num_Bin )
             #                 y_data=spc+wnoise
             #
             #                 # single gaussian
             #                 #shift0=numpy.mod(midpeak+minx,64)
             #                 shift0=numpy.mod(midpeak+minx, self.Num_Bin )
             #                 width0=powerwidth/4.#Initialization entire power of spectrum divided by 4
             #                 power0=2.
             #                 amplitude0=midamp
             #                 state0=[shift0,width0,amplitude0,power0,wnoise]
             #                 #bnds=((0,63),(1,powerwidth),(0,None),(0.5,3.),(noisebl,noisebh))
             #                 bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth),(0,None),(0.5,3.),(noisebl,noisebh))
             #                 #bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth),(0,None),(0.5,3.),(0.1,0.5))
             #                 # bnds = range of fft, power width, amplitude, power, noise
             #                 lsq1=fmin_l_bfgs_b(self.misfit1,state0,args=(y_data,x,num_intg),bounds=bnds,approx_grad=True)
             #
             #                 chiSq1=lsq1[1];
             #                 jack1= self.y_jacobian1(x,lsq1[0])
             #
             #
             #                 try:
             #                     sigmas1=numpy.sqrt(chiSq1*numpy.diag(numpy.linalg.inv(numpy.dot(jack1.T,jack1))))
             #                 except:
             #                     std1=32.; sigmas1=numpy.ones(5)
             #                 else:
             #                     std1=sigmas1[0]
             #
             #
             #                 if fatspectra<1.0 and powerwidth<4:
             #                         choice=0
             #                         Amplitude0=lsq1[0][2]
             #                         shift0=lsq1[0][0]
             #                         width0=lsq1[0][1]
             #                         p0=lsq1[0][3]
             #                         Amplitude1=0.
             #                         shift1=0.
             #                         width1=0.
             #                         p1=0.
             #                         noise=lsq1[0][4]
             #                         #return (numpy.array([shift0,width0,Amplitude0,p0]),
             #                         #        numpy.array([shift1,width1,Amplitude1,p1]),noise,snrdB,chiSq1,6.,sigmas1,[None,]*9,choice)
             #
             #                 # two gaussians
             #                 #shift0=numpy.mod(firstpeak+minx,64); shift1=numpy.mod(secondpeak+minx,64)
             #                 shift0=numpy.mod(firstpeak+minx, self.Num_Bin );
             #                 shift1=numpy.mod(secondpeak+minx, self.Num_Bin )
             #                 width0=powerwidth/6.;
             #                 width1=width0
             #                 power0=2.;
             #                 power1=power0
             #                 amplitude0=firstamp;
             #                 amplitude1=secondamp
             #                 state0=[shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,wnoise]
             #                 #bnds=((0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
             #                 bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
             #                 #bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(0.1,0.5))
             #
             #                 lsq2=fmin_l_bfgs_b(self.misfit2,state0,args=(y_data,x,num_intg),bounds=bnds,approx_grad=True)
             #
             #
             #                 chiSq2=lsq2[1]; jack2=self.y_jacobian2(x,lsq2[0])
             #
             #
             #                 try:
             #                     sigmas2=numpy.sqrt(chiSq2*numpy.diag(numpy.linalg.inv(numpy.dot(jack2.T,jack2))))
             #                 except:
             #                     std2a=32.; std2b=32.; sigmas2=numpy.ones(9)
             #                 else:
             #                     std2a=sigmas2[0]; std2b=sigmas2[4]
             #
             #
             #
             #                 oneG=(chiSq1<5 and chiSq1/chiSq2<2.0) and (abs(lsq2[0][0]-lsq2[0][4])<(lsq2[0][1]+lsq2[0][5])/3. or abs(lsq2[0][0]-lsq2[0][4])<10)
             #
             #                 if snrdB>-9: # when SNR is strong pick the peak with least shift (LOS velocity) error
             #                     if oneG:
             #                         choice=0
             #                     else:
             #                         w1=lsq2[0][1]; w2=lsq2[0][5]
             #                         a1=lsq2[0][2]; a2=lsq2[0][6]
             #                         p1=lsq2[0][3]; p2=lsq2[0][7]
             #                         s1=(2**(1+1./p1))*scipy.special.gamma(1./p1)/p1; s2=(2**(1+1./p2))*scipy.special.gamma(1./p2)/p2;
             #                         gp1=a1*w1*s1; gp2=a2*w2*s2 # power content of each ggaussian with proper p scaling
             #
             #                         if gp1>gp2:
             #                             if a1>0.7*a2:
             #                                 choice=1
             #                             else:
             #                                 choice=2
             #                         elif gp2>gp1:
             #                             if a2>0.7*a1:
             #                                 choice=2
             #                             else:
             #                                 choice=1
             #                         else:
             #                             choice=numpy.argmax([a1,a2])+1
             #                             #else:
             #                             #choice=argmin([std2a,std2b])+1
             #
             #                 else: # with low SNR go to the most energetic peak
             #                     choice=numpy.argmax([lsq1[0][2]*lsq1[0][1],lsq2[0][2]*lsq2[0][1],lsq2[0][6]*lsq2[0][5]])
             #
             #                 #print 'choice',choice
             #
             #                 if choice==0: # pick the single gaussian fit
             #                     Amplitude0=lsq1[0][2]
             #                     shift0=lsq1[0][0]
             #                     width0=lsq1[0][1]
             #                     p0=lsq1[0][3]
             #                     Amplitude1=0.
             #                     shift1=0.
             #                     width1=0.
             #                     p1=0.
             #                     noise=lsq1[0][4]
             #                 elif choice==1: # take the first one of the 2 gaussians fitted
             #                     Amplitude0 = lsq2[0][2]
             #                     shift0     = lsq2[0][0]
             #                     width0     = lsq2[0][1]
             #                     p0         = lsq2[0][3]
             #                     Amplitude1 = lsq2[0][6]     # This is 0 in gg1
             #                     shift1     = lsq2[0][4]     # This is 0 in gg1
             #                     width1     = lsq2[0][5]     # This is 0 in gg1
             #                     p1         = lsq2[0][7]     # This is 0 in gg1
             #                     noise      = lsq2[0][8]
             #                 else: # the second one
             #                     Amplitude0 = lsq2[0][6]
             #                     shift0     = lsq2[0][4]
             #                     width0     = lsq2[0][5]
             #                     p0         = lsq2[0][7]
             #                     Amplitude1 = lsq2[0][2]     # This is 0 in gg1
             #                     shift1     = lsq2[0][0]     # This is 0 in gg1
             #                     width1     = lsq2[0][1]     # This is 0 in gg1
             #                     p1         = lsq2[0][3]     # This is 0 in gg1
             #                     noise      = lsq2[0][8]
             #
             #                 #print len(noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0))/width0)**p0)
             #                 SPC_ch1[:,ht] = noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0))/width0)**p0
             #                 SPC_ch2[:,ht] = noise + Amplitude1*numpy.exp(-0.5*(abs(x-shift1))/width1)**p1
             #                 #print 'SPC_ch1.shape',SPC_ch1.shape
             #                 #print 'SPC_ch2.shape',SPC_ch2.shape
             #                 #dataOut.data_param = SPC_ch1
             #                 GauSPC[0] = SPC_ch1
             #                 GauSPC[1] = SPC_ch2
             #                 #plt.gcf().clear()
             #                plt.figure(50+self.i)
             #                self.i=self.i+1
             #                 #plt.subplot(121)
             #                plt.plot(self.spc,'k')#,label='spc(66)')
             #                plt.plot(SPC_ch1[ch,ht],'b')#,label='gg1')
             #                 #plt.plot(SPC_ch2,'r')#,label='gg2')
             #                 #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 7500 METROS')
             #                plt.show()
             #             print 'shift0', shift0
             #             print 'Amplitude0', Amplitude0
             #             print 'width0', width0
             #             print 'p0', p0
             #             print '========================'
             #             print 'shift1', shift1
             #             print 'Amplitude1', Amplitude1
             #             print 'width1', width1
             #             print 'p1', p1
             #             print 'noise', noise
             #             print 's_noise', wnoise
                     print '========================================================'
                     print 'total_time: ', time.time()-start_time
                             # re-normalizing spc and noise
                             # This part differs from gg1
                     ''' Parameters:
 . Amplitude
 . Shift
 . Width
 . Power
                            '''
                     ###############################################################################
                 def FitGau(self, X):
                     Vrange, ch, pnoise, noise_, num_intg, SNRlimit = X
                     #print 'VARSSSS', ch, pnoise, noise, num_intg
                     #print 'HEIGHTS', self.Num_Hei
                     GauSPC = []
                     SPC_ch1 = numpy.empty([self.Num_Bin,self.Num_Hei])
                     SPC_ch2 = numpy.empty([self.Num_Bin,self.Num_Hei])
                     SPC_ch1[:] = 0#numpy.NaN
                     SPC_ch2[:] = 0#numpy.NaN
                     for ht in range(self.Num_Hei):
                         #print (numpy.asarray(self.spc).shape)
                         #print 'TTTTT', ch , ht
                         #print self.spc.shape
                         spc =  numpy.asarray(self.spc)[ch,:,ht]
                         #############################################
                         # normalizing spc and noise
                         # This part differs from gg1
                         spc_norm_max = max(spc)
                         spc = spc / spc_norm_max
                         pnoise = pnoise / spc_norm_max
                         #############################################
                         fatspectra=1.0
                         wnoise = noise_ / spc_norm_max
                             #wnoise,stdv,i_max,index =enoise(spc,num_intg) #noise estimate using Hildebrand Sekhon, only wnoise is used
                             #if wnoise>1.1*pnoise: # to be tested later
                             #    wnoise=pnoise
                         noisebl=wnoise*0.9; noisebh=wnoise*1.1
                         spc=spc-wnoise
                         # print 'wnoise', noise_[0], spc_norm_max, wnoise
                         minx=numpy.argmin(spc)
                         spcs=numpy.roll(spc,-minx)
                         cum=numpy.cumsum(spcs)
                         tot_noise=wnoise * self.Num_Bin  #64;
                         #print 'spc' , spcs[5:8] , 'tot_noise', tot_noise
                         #tot_signal=sum(cum[-5:])/5.; ''' How does this line work? '''
                         #snr=tot_signal/tot_noise
                         #snr=cum[-1]/tot_noise
                         snr = sum(spcs)/tot_noise
                         snrdB=10.*numpy.log10(snr)
                         if snrdB < SNRlimit :
                             snr = numpy.NaN
                             SPC_ch1[:,ht] = 0#numpy.NaN
                             SPC_ch1[:,ht] = 0#numpy.NaN
                             GauSPC = (SPC_ch1,SPC_ch2)
                             continue
                         #print 'snr',snrdB #, sum(spcs) , tot_noise
                         #if snrdB<-18 or numpy.isnan(snrdB) or num_intg<4:
                         #    return [None,]*4,[None,]*4,None,snrdB,None,None,[None,]*5,[None,]*9,None
                         cummax=max(cum); epsi=0.08*fatspectra # cumsum to narrow down the energy region
                         cumlo=cummax*epsi;
                         cumhi=cummax*(1-epsi)
                         powerindex=numpy.array(numpy.where(numpy.logical_and(cum>cumlo, cum<cumhi))[0])
                         if len(powerindex) < 1:# case for powerindex 0
                             continue
                         powerlo=powerindex[0]
                         powerhi=powerindex[-1]
                         powerwidth=powerhi-powerlo
                         firstpeak=powerlo+powerwidth/10.# first gaussian energy location
                         secondpeak=powerhi-powerwidth/10.#second gaussian energy location
                         midpeak=(firstpeak+secondpeak)/2.
                         firstamp=spcs[int(firstpeak)]
                         secondamp=spcs[int(secondpeak)]
                         midamp=spcs[int(midpeak)]
                         x=numpy.arange( self.Num_Bin )
                         y_data=spc+wnoise
                         # single gaussian
                         shift0=numpy.mod(midpeak+minx, self.Num_Bin )
                         width0=powerwidth/4.#Initialization entire power of spectrum divided by 4
                         power0=2.
                         amplitude0=midamp
                         state0=[shift0,width0,amplitude0,power0,wnoise]
                         bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth),(0,None),(0.5,3.),(noisebl,noisebh))
                         lsq1=fmin_l_bfgs_b(self.misfit1,state0,args=(y_data,x,num_intg),bounds=bnds,approx_grad=True)
                         chiSq1=lsq1[1];
                         jack1= self.y_jacobian1(x,lsq1[0])
                         try:
                             sigmas1=numpy.sqrt(chiSq1*numpy.diag(numpy.linalg.inv(numpy.dot(jack1.T,jack1))))
                         except:
                             std1=32.; sigmas1=numpy.ones(5)
                         else:
                             std1=sigmas1[0]
                         if fatspectra<1.0 and powerwidth<4:
                                 choice=0
                                 Amplitude0=lsq1[0][2]
                                 shift0=lsq1[0][0]
                                 width0=lsq1[0][1]
                                 p0=lsq1[0][3]
                                 Amplitude1=0.
                                 shift1=0.
                                 width1=0.
                                 p1=0.
                                 noise=lsq1[0][4]
                                 #return (numpy.array([shift0,width0,Amplitude0,p0]),
                                 #        numpy.array([shift1,width1,Amplitude1,p1]),noise,snrdB,chiSq1,6.,sigmas1,[None,]*9,choice)
                         # two gaussians
                         #shift0=numpy.mod(firstpeak+minx,64); shift1=numpy.mod(secondpeak+minx,64)
                         shift0=numpy.mod(firstpeak+minx, self.Num_Bin );
                         shift1=numpy.mod(secondpeak+minx, self.Num_Bin )
                         width0=powerwidth/6.;
                         width1=width0
                         power0=2.;
                         power1=power0
                         amplitude0=firstamp;
                         amplitude1=secondamp
                         state0=[shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,wnoise]
                         #bnds=((0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(0,63),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
                         bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(noisebl,noisebh))
                         #bnds=(( 0,(self.Num_Bin-1) ),(1,powerwidth/2.),(0,None),(0.5,3.),( 0,(self.Num_Bin-1)),(1,powerwidth/2.),(0,None),(0.5,3.),(0.1,0.5))
                         lsq2=fmin_l_bfgs_b(self.misfit2,state0,args=(y_data,x,num_intg),bounds=bnds,approx_grad=True)
                         chiSq2=lsq2[1]; jack2=self.y_jacobian2(x,lsq2[0])
                         try:
                             sigmas2=numpy.sqrt(chiSq2*numpy.diag(numpy.linalg.inv(numpy.dot(jack2.T,jack2))))
                         except:
                             std2a=32.; std2b=32.; sigmas2=numpy.ones(9)
                         else:
                             std2a=sigmas2[0]; std2b=sigmas2[4]
                         oneG=(chiSq1<5 and chiSq1/chiSq2<2.0) and (abs(lsq2[0][0]-lsq2[0][4])<(lsq2[0][1]+lsq2[0][5])/3. or abs(lsq2[0][0]-lsq2[0][4])<10)
                         if snrdB>-6: # when SNR is strong pick the peak with least shift (LOS velocity) error
                             if oneG:
                                 choice=0
                             else:
                                 w1=lsq2[0][1]; w2=lsq2[0][5]
                                 a1=lsq2[0][2]; a2=lsq2[0][6]
                                 p1=lsq2[0][3]; p2=lsq2[0][7]
                                 s1=(2**(1+1./p1))*scipy.special.gamma(1./p1)/p1;
                                 s2=(2**(1+1./p2))*scipy.special.gamma(1./p2)/p2;
                                 gp1=a1*w1*s1; gp2=a2*w2*s2 # power content of each ggaussian with proper p scaling
                                 if gp1>gp2:
                                     if a1>0.7*a2:
                                         choice=1
                                     else:
                                         choice=2
                                 elif gp2>gp1:
                                     if a2>0.7*a1:
                                         choice=2
                                     else:
                                         choice=1
                                 else:
                                     choice=numpy.argmax([a1,a2])+1
                                     #else:
                                     #choice=argmin([std2a,std2b])+1
                         else: # with low SNR go to the most energetic peak
                             choice=numpy.argmax([lsq1[0][2]*lsq1[0][1],lsq2[0][2]*lsq2[0][1],lsq2[0][6]*lsq2[0][5]])
                         shift0=lsq2[0][0]; vel0=Vrange[0] + shift0*(Vrange[1]-Vrange[0])
                         shift1=lsq2[0][4]; vel1=Vrange[0] + shift1*(Vrange[1]-Vrange[0])
                         max_vel = 20
                         #first peak will be 0, second peak will be 1
                         if vel0 > 0 and vel0 < max_vel : #first peak is in the correct range
                             shift0=lsq2[0][0]
                             width0=lsq2[0][1]
                             Amplitude0=lsq2[0][2]
                             p0=lsq2[0][3]
                             shift1=lsq2[0][4]
                             width1=lsq2[0][5]
                             Amplitude1=lsq2[0][6]
                             p1=lsq2[0][7]
                             noise=lsq2[0][8]
                         else:
                             shift1=lsq2[0][0]
                             width1=lsq2[0][1]
                             Amplitude1=lsq2[0][2]
                             p1=lsq2[0][3]
                             shift0=lsq2[0][4]
                             width0=lsq2[0][5]
                             Amplitude0=lsq2[0][6]
                             p0=lsq2[0][7]
                             noise=lsq2[0][8]
                         if Amplitude0<0.1: # in case the peak is noise
                             shift0,width0,Amplitude0,p0 = 4*[numpy.NaN]
                         if Amplitude1<0.1:
                             shift1,width1,Amplitude1,p1 = 4*[numpy.NaN]
             #             if choice==0: # pick the single gaussian fit
             #                 Amplitude0=lsq1[0][2]
             #                 shift0=lsq1[0][0]
             #                 width0=lsq1[0][1]
             #                 p0=lsq1[0][3]
             #                 Amplitude1=0.
             #                 shift1=0.
             #                 width1=0.
             #                 p1=0.
             #                 noise=lsq1[0][4]
             #             elif choice==1: # take the first one of the 2 gaussians fitted
             #                 Amplitude0 = lsq2[0][2]
             #                 shift0     = lsq2[0][0]
             #                 width0     = lsq2[0][1]
             #                 p0         = lsq2[0][3]
             #                 Amplitude1 = lsq2[0][6]     # This is 0 in gg1
             #                 shift1     = lsq2[0][4]     # This is 0 in gg1
             #                 width1     = lsq2[0][5]     # This is 0 in gg1
             #                 p1         = lsq2[0][7]     # This is 0 in gg1
             #                 noise      = lsq2[0][8]
             #             else: # the second one
             #                 Amplitude0 = lsq2[0][6]
             #                 shift0     = lsq2[0][4]
             #                 width0     = lsq2[0][5]
             #                 p0         = lsq2[0][7]
             #                 Amplitude1 = lsq2[0][2]     # This is 0 in gg1
             #                 shift1     = lsq2[0][0]     # This is 0 in gg1
             #                 width1     = lsq2[0][1]     # This is 0 in gg1
             #                 p1         = lsq2[0][3]     # This is 0 in gg1
             #                 noise      = lsq2[0][8]
                         #print len(noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0))/width0)**p0)
                         SPC_ch1[:,ht] = noise + Amplitude0*numpy.exp(-0.5*(abs(x-shift0))/width0)**p0
                         SPC_ch2[:,ht] = noise + Amplitude1*numpy.exp(-0.5*(abs(x-shift1))/width1)**p1
                         #print 'SPC_ch1.shape',SPC_ch1.shape
                         #print 'SPC_ch2.shape',SPC_ch2.shape
                         #dataOut.data_param = SPC_ch1
                         GauSPC = (SPC_ch1,SPC_ch2)
                         #GauSPC[1] = SPC_ch2
             #         print 'shift0', shift0
             #         print 'Amplitude0', Amplitude0
             #         print 'width0', width0
             #         print 'p0', p0
             #         print '========================'
             #         print 'shift1', shift1
             #         print 'Amplitude1', Amplitude1
             #         print 'width1', width1
             #         print 'p1', p1
             #         print 'noise', noise
             #         print 's_noise', wnoise
                     return GauSPC
                 def y_jacobian1(self,x,state): # This function is for further analysis of generalized Gaussians, it is not too importan for the signal discrimination.
                     y_model=self.y_model1(x,state)
                     s0,w0,a0,p0,n=state
                     e0=((x-s0)/w0)**2;
                     e0u=((x-s0-self.Num_Bin)/w0)**2;
                     e0d=((x-s0+self.Num_Bin)/w0)**2
                     m0=numpy.exp(-0.5*e0**(p0/2.));
                     m0u=numpy.exp(-0.5*e0u**(p0/2.));
                     m0d=numpy.exp(-0.5*e0d**(p0/2.))
                     JA=m0+m0u+m0d
                     JP=(-1/4.)*a0*m0*e0**(p0/2.)*numpy.log(e0)+(-1/4.)*a0*m0u*e0u**(p0/2.)*numpy.log(e0u)+(-1/4.)*a0*m0d*e0d**(p0/2.)*numpy.log(e0d)
                     JS=(p0/w0/2.)*a0*m0*e0**(p0/2.-1)*((x-s0)/w0)+(p0/w0/2.)*a0*m0u*e0u**(p0/2.-1)*((x-s0- self.Num_Bin )/w0)+(p0/w0/2.)*a0*m0d*e0d**(p0/2.-1)*((x-s0+ self.Num_Bin )/w0)
                     JW=(p0/w0/2.)*a0*m0*e0**(p0/2.-1)*((x-s0)/w0)**2+(p0/w0/2.)*a0*m0u*e0u**(p0/2.-1)*((x-s0- self.Num_Bin )/w0)**2+(p0/w0/2.)*a0*m0d*e0d**(p0/2.-1)*((x-s0+ self.Num_Bin )/w0)**2
                     jack1=numpy.sqrt(7)*numpy.array([JS/y_model,JW/y_model,JA/y_model,JP/y_model,1./y_model])
                     return jack1.T
                 def y_jacobian2(self,x,state):
                     y_model=self.y_model2(x,state)
                     s0,w0,a0,p0,s1,w1,a1,p1,n=state
                     e0=((x-s0)/w0)**2;
                     e0u=((x-s0- self.Num_Bin )/w0)**2;
                     e0d=((x-s0+ self.Num_Bin )/w0)**2
                     e1=((x-s1)/w1)**2;
                     e1u=((x-s1- self.Num_Bin )/w1)**2;
                     e1d=((x-s1+ self.Num_Bin )/w1)**2
                     m0=numpy.exp(-0.5*e0**(p0/2.));
                     m0u=numpy.exp(-0.5*e0u**(p0/2.));
                     m0d=numpy.exp(-0.5*e0d**(p0/2.))
                     m1=numpy.exp(-0.5*e1**(p1/2.));
                     m1u=numpy.exp(-0.5*e1u**(p1/2.));
                     m1d=numpy.exp(-0.5*e1d**(p1/2.))
                     JA=m0+m0u+m0d
                     JA1=m1+m1u+m1d
                     JP=(-1/4.)*a0*m0*e0**(p0/2.)*numpy.log(e0)+(-1/4.)*a0*m0u*e0u**(p0/2.)*numpy.log(e0u)+(-1/4.)*a0*m0d*e0d**(p0/2.)*numpy.log(e0d)
                     JP1=(-1/4.)*a1*m1*e1**(p1/2.)*numpy.log(e1)+(-1/4.)*a1*m1u*e1u**(p1/2.)*numpy.log(e1u)+(-1/4.)*a1*m1d*e1d**(p1/2.)*numpy.log(e1d)
                     JS=(p0/w0/2.)*a0*m0*e0**(p0/2.-1)*((x-s0)/w0)+(p0/w0/2.)*a0*m0u*e0u**(p0/2.-1)*((x-s0- self.Num_Bin )/w0)+(p0/w0/2.)*a0*m0d*e0d**(p0/2.-1)*((x-s0+ self.Num_Bin )/w0)
                     JS1=(p1/w1/2.)*a1*m1*e1**(p1/2.-1)*((x-s1)/w1)+(p1/w1/2.)*a1*m1u*e1u**(p1/2.-1)*((x-s1- self.Num_Bin )/w1)+(p1/w1/2.)*a1*m1d*e1d**(p1/2.-1)*((x-s1+ self.Num_Bin )/w1)
                     JW=(p0/w0/2.)*a0*m0*e0**(p0/2.-1)*((x-s0)/w0)**2+(p0/w0/2.)*a0*m0u*e0u**(p0/2.-1)*((x-s0- self.Num_Bin )/w0)**2+(p0/w0/2.)*a0*m0d*e0d**(p0/2.-1)*((x-s0+ self.Num_Bin )/w0)**2
                     JW1=(p1/w1/2.)*a1*m1*e1**(p1/2.-1)*((x-s1)/w1)**2+(p1/w1/2.)*a1*m1u*e1u**(p1/2.-1)*((x-s1- self.Num_Bin )/w1)**2+(p1/w1/2.)*a1*m1d*e1d**(p1/2.-1)*((x-s1+ self.Num_Bin )/w1)**2
                     jack2=numpy.sqrt(7)*numpy.array([JS/y_model,JW/y_model,JA/y_model,JP/y_model,JS1/y_model,JW1/y_model,JA1/y_model,JP1/y_model,1./y_model])
                     return jack2.T
                 def y_model1(self,x,state):
                     shift0,width0,amplitude0,power0,noise=state
                     model0=amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
                     model0u=amplitude0*numpy.exp(-0.5*abs((x-shift0- self.Num_Bin )/width0)**power0)
                     model0d=amplitude0*numpy.exp(-0.5*abs((x-shift0+ self.Num_Bin )/width0)**power0)
                     return model0+model0u+model0d+noise
                 def y_model2(self,x,state): #Equation for two generalized Gaussians with Nyquist
                     shift0,width0,amplitude0,power0,shift1,width1,amplitude1,power1,noise=state
                     model0=amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
                     model0u=amplitude0*numpy.exp(-0.5*abs((x-shift0- self.Num_Bin )/width0)**power0)
                     model0d=amplitude0*numpy.exp(-0.5*abs((x-shift0+ self.Num_Bin )/width0)**power0)
                     model1=amplitude1*numpy.exp(-0.5*abs((x-shift1)/width1)**power1)
                     model1u=amplitude1*numpy.exp(-0.5*abs((x-shift1- self.Num_Bin )/width1)**power1)
                     model1d=amplitude1*numpy.exp(-0.5*abs((x-shift1+ self.Num_Bin )/width1)**power1)
                     return model0+model0u+model0d+model1+model1u+model1d+noise
                 def misfit1(self,state,y_data,x,num_intg): # This function compares how close real data is with the model data, the close it is, the better it is.
                     return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model1(x,state)))**2)#/(64-5.) # /(64-5.) can be commented
                 def misfit2(self,state,y_data,x,num_intg):
                     return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))**2)#/(64-9.)
             class PrecipitationProc(Operation):
                 '''
                      Operator that estimates Reflectivity factor (Z), and estimates rainfall Rate (R)
                      Input:
                         self.dataOut.data_pre    :    SelfSpectra
                      Output:
                         self.dataOut.data_output :    Reflectivity factor, rainfall Rate
                      Parameters affected:
                 '''
                 def run(self, dataOut, radar=None, Pt=None, Gt=None, Gr=None, Lambda=None, aL=None,
                         tauW=None, ThetaT=None, ThetaR=None, Km = 0.93, Altitude=None):
                     self.spc = dataOut.data_pre[0].copy()
                     self.Num_Hei = self.spc.shape[2]
                     self.Num_Bin = self.spc.shape[1]
                     self.Num_Chn = self.spc.shape[0]
                     Velrange = dataOut.abscissaList
                     if radar == "MIRA35C" :
                         Ze = self.dBZeMODE2(dataOut)
                     else:
                         self.Pt = Pt
                         self.Gt = Gt
                         self.Gr = Gr
                         self.Lambda = Lambda
                         self.aL = aL
                         self.tauW = tauW
                         self.ThetaT = ThetaT
                         self.ThetaR = ThetaR
                         RadarConstant = GetRadarConstant()
                         SPCmean = numpy.mean(self.spc,0)
                         ETA = numpy.zeros(self.Num_Hei)
                         Pr = numpy.sum(SPCmean,0)
                         #for R in range(self.Num_Hei):
                         #    ETA[R] = RadarConstant * Pr[R] * R**2 #Reflectivity (ETA)
                         D_range = numpy.zeros(self.Num_Hei)
                         EqSec = numpy.zeros(self.Num_Hei)
                         del_V = numpy.zeros(self.Num_Hei)
                         for R in range(self.Num_Hei):
                             ETA[R] = RadarConstant * Pr[R] * R**2 #Reflectivity (ETA)
                             h = R + Altitude #Range from ground to radar pulse altitude
                             del_V[R] = 1 + 3.68 * 10**-5 * h + 1.71 * 10**-9 * h**2    #Density change correction for velocity
                             D_range[R] = numpy.log( (9.65 - (Velrange[R]/del_V[R])) / 10.3 ) / -0.6 #Range of Diameter of drops related to velocity
                             SIGMA[R] = numpy.pi**5 / Lambda**4 * Km * D_range[R]**6     #Equivalent Section of drops (sigma)
                             N_dist[R] = ETA[R] / SIGMA[R]
                         Ze = (ETA * Lambda**4) / (numpy.pi * Km)
                         Z = numpy.sum( N_dist * D_range**6 )
                         RR = 6*10**-4*numpy.pi * numpy.sum( D_range**3 * N_dist * Velrange ) #Rainfall rate
                     RR = (Ze/200)**(1/1.6)
                     dBRR = 10*numpy.log10(RR)
                     dBZe = 10*numpy.log10(Ze)
                     dataOut.data_output = Ze
                     dataOut.data_param = numpy.ones([2,self.Num_Hei])
                     dataOut.channelList = [0,1]
                     print 'channelList', dataOut.channelList
                     dataOut.data_param[0]=dBZe
                     dataOut.data_param[1]=dBRR
                     print 'RR SHAPE', dBRR.shape
                     print 'Ze SHAPE', dBZe.shape
                     print 'dataOut.data_param SHAPE', dataOut.data_param.shape
                 def dBZeMODE2(self, dataOut): #    Processing for MIRA35C
                     NPW = dataOut.NPW
                     COFA = dataOut.COFA
                     SNR = numpy.array([self.spc[0,:,:] / NPW[0]]) #, self.spc[1,:,:] / NPW[1]])
                     RadarConst = dataOut.RadarConst
                     #frequency = 34.85*10**9
                     ETA = numpy.zeros(([self.Num_Chn ,self.Num_Hei]))
                     data_output = numpy.ones([self.Num_Chn , self.Num_Hei])*numpy.NaN
                     ETA = numpy.sum(SNR,1)
                     print 'ETA' , ETA
                     ETA = numpy.where(ETA is not 0. , ETA, numpy.NaN)
                     Ze = numpy.ones([self.Num_Chn, self.Num_Hei] )
                     for r in range(self.Num_Hei):
                         Ze[0,r] =  ( ETA[0,r] ) * COFA[0,r][0] * RadarConst * ((r/5000.)**2)
                         #Ze[1,r] =  ( ETA[1,r] ) * COFA[1,r][0] * RadarConst * ((r/5000.)**2)
                     return Ze
                 def GetRadarConstant(self):
                     """
                     Constants:
-                    Pt:     Transmission Power               dB
+                    Pt:     Transmission Power               dB        5kW
-                    Gt:     Transmission Gain                dB
+                    Gt:     Transmission Gain                dB        24.7 dB
-                    Gr:     Reception Gain                   dB
+                    Gr:     Reception Gain                   dB        18.5 dB
-                    Lambda: Wavelenght                       m
+                    Lambda: Wavelenght                       m         0.6741 m
-                    aL:      Attenuation loses               dB
+                    aL:     Attenuation loses                dB
                     tauW:   Width of transmission pulse      s
-                    ThetaT: Transmission antenna bean angle  rad
+                    ThetaT: Transmission antenna bean angle  rad       0.1656317 rad
-                    ThetaR: Reception antenna beam angle     rad
+                    ThetaR: Reception antenna beam angle     rad       0.36774087 rad
                     """
                     Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
                     Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * TauW * numpy.pi * ThetaT * TheraR)
                     RadarConstant =  Numerator / Denominator
                     return RadarConstant
             class FullSpectralAnalysis(Operation):
                 """
                     Function that implements Full Spectral Analisys technique.
                     Input:
                         self.dataOut.data_pre    :    SelfSpectra and CrossSPectra data
                         self.dataOut.groupList   :    Pairlist of channels
                         self.dataOut.ChanDist    :    Physical distance between receivers
                     Output:
                         self.dataOut.data_output :    Zonal wind, Meridional wind and Vertical wind
                     Parameters affected:    Winds, height range, SNR
                 """
                 def run(self, dataOut, E01=None, E02=None, E12=None, N01=None, N02=None, N12=None, SNRlimit=7):
                     spc = dataOut.data_pre[0].copy()
                     cspc = dataOut.data_pre[1].copy()
                     nChannel = spc.shape[0]
                     nProfiles = spc.shape[1]
                     nHeights = spc.shape[2]
                     pairsList = dataOut.groupList
                     if dataOut.ChanDist is not None :
                         ChanDist = dataOut.ChanDist
                     else:
                         ChanDist = numpy.array([[E01, N01],[E02,N02],[E12,N12]])
                     #print 'ChanDist', ChanDist
                     if dataOut.VelRange is not None:
                         VelRange= dataOut.VelRange
                     else:
                         VelRange= dataOut.abscissaList
                     ySamples=numpy.ones([nChannel,nProfiles])
                     phase=numpy.ones([nChannel,nProfiles])
                     CSPCSamples=numpy.ones([nChannel,nProfiles],dtype=numpy.complex_)
                     coherence=numpy.ones([nChannel,nProfiles])
                     PhaseSlope=numpy.ones(nChannel)
                     PhaseInter=numpy.ones(nChannel)
                     dataSNR = dataOut.data_SNR
                     data = dataOut.data_pre
                     noise = dataOut.noise
-                    print 'noise',noise
+                    #print 'noise',noise
                     #SNRdB = 10*numpy.log10(dataOut.data_SNR)
                     FirstMoment = numpy.average(dataOut.data_param[:,1,:],0)
                     #SNRdBMean = []
                     #for j in range(nHeights):
                     #    FirstMoment = numpy.append(FirstMoment,numpy.mean([dataOut.data_param[0,1,j],dataOut.data_param[1,1,j],dataOut.data_param[2,1,j]]))
                     #    SNRdBMean = numpy.append(SNRdBMean,numpy.mean([SNRdB[0,j],SNRdB[1,j],SNRdB[2,j]]))
                     data_output=numpy.ones([3,spc.shape[2]])*numpy.NaN
                     velocityX=[]
                     velocityY=[]
                     velocityV=[]
+                    PhaseLine=[]
                     dbSNR = 10*numpy.log10(dataSNR)
                     dbSNR = numpy.average(dbSNR,0)
                     for Height in range(nHeights):
-                        [Vzon,Vmer,Vver, GaussCenter]= self.WindEstimation(spc, cspc, pairsList, ChanDist, Height, noise, VelRange, dbSNR[Height], SNRlimit)
+                        [Vzon,Vmer,Vver, GaussCenter, PhaseSlope]= self.WindEstimation(spc, cspc, pairsList, ChanDist, Height, noise, VelRange, dbSNR[Height], SNRlimit)
+                        PhaseLine = numpy.append(PhaseLine, PhaseSlope)
                         if abs(Vzon)<100. and abs(Vzon)> 0.:
                             velocityX=numpy.append(velocityX, Vzon)#Vmag
                         else:
-                            print 'Vzon',Vzon
+                            #print 'Vzon',Vzon
                             velocityX=numpy.append(velocityX, numpy.NaN)
                         if abs(Vmer)<100. and abs(Vmer) > 0.:
                             velocityY=numpy.append(velocityY, Vmer)#Vang
                         else:
-                            print 'Vmer',Vmer
+                            #print 'Vmer',Vmer
                             velocityY=numpy.append(velocityY, numpy.NaN)
                         if dbSNR[Height] > SNRlimit:
                             velocityV=numpy.append(velocityV, FirstMoment[Height])
                         else:
                             velocityV=numpy.append(velocityV, numpy.NaN)
                             #FirstMoment[Height]= numpy.NaN
             #             if SNRdBMean[Height]  <12:
             #                 FirstMoment[Height] = numpy.NaN
             #                 velocityX[Height] = numpy.NaN
             #                 velocityY[Height] = numpy.NaN
                     data_output[0]=numpy.array(velocityX)
                     data_output[1]=numpy.array(velocityY)
                     data_output[2]=-velocityV#FirstMoment
                     print ' '
                     #print 'FirstMoment'
                     #print FirstMoment
                     print 'velocityX',data_output[0]
                     print ' '
                     print 'velocityY',data_output[1]
+                    print 'PhaseLine',PhaseLine
                     #print numpy.array(velocityY)
                     print ' '
                     #print 'SNR'
                     #print 10*numpy.log10(dataOut.data_SNR)
                     #print numpy.shape(10*numpy.log10(dataOut.data_SNR))
                     print ' '
                     dataOut.data_output=data_output
                     return
                 def moving_average(self,x, N=2):
                     return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
                 def gaus(self,xSamples,a,x0,sigma):
                     return a*numpy.exp(-(xSamples-x0)**2/(2*sigma**2))
                 def Find(self,x,value):
                     for index in range(len(x)):
                         if x[index]==value:
                             return index
                 def WindEstimation(self, spc, cspc, pairsList, ChanDist, Height, noise, VelRange, dbSNR, SNRlimit):
                     ySamples=numpy.ones([spc.shape[0],spc.shape[1]])
                     phase=numpy.ones([spc.shape[0],spc.shape[1]])
                     CSPCSamples=numpy.ones([spc.shape[0],spc.shape[1]],dtype=numpy.complex_)
                     coherence=numpy.ones([spc.shape[0],spc.shape[1]])
-                    PhaseSlope=numpy.ones(spc.shape[0])
+                    PhaseSlope=numpy.zeros(spc.shape[0])
                     PhaseInter=numpy.ones(spc.shape[0])
                     xFrec=VelRange
                     '''Getting Eij and Nij'''
                     E01=ChanDist[0][0]
                     N01=ChanDist[0][1]
                     E02=ChanDist[1][0]
                     N02=ChanDist[1][1]
                     E12=ChanDist[2][0]
                     N12=ChanDist[2][1]
                     z = spc.copy()
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     for i in range(spc.shape[0]):
                         '''****** Line of Data SPC ******'''
                         zline=z[i,:,Height]
                         '''****** SPC is normalized ******'''
                         FactNorm= (zline.copy()-noise[i]) / numpy.sum(zline.copy())
                         FactNorm= FactNorm/numpy.sum(FactNorm)
                         SmoothSPC=self.moving_average(FactNorm,N=3)
                         xSamples = ar(range(len(SmoothSPC)))
                         ySamples[i] = SmoothSPC
                     #dbSNR=10*numpy.log10(dataSNR)
                     print ' '
                     print ' '
                     print ' '
                     #print 'dataSNR', dbSNR.shape, dbSNR[0,40:120]
-                    print 'SmoothSPC', SmoothSPC.shape, SmoothSPC[0:20]
+                    #print 'SmoothSPC', SmoothSPC.shape, SmoothSPC[0:20]
-                    print 'noise',noise
+                    #print 'noise',noise
-                    print 'zline',zline.shape, zline[0:20]
+                    #print 'zline',zline.shape, zline[0:20]
-                    print 'FactNorm',FactNorm.shape, FactNorm[0:20]
+                    #print 'FactNorm',FactNorm.shape, FactNorm[0:20]
-                    print 'FactNorm suma', numpy.sum(FactNorm)
+                    #print 'FactNorm suma', numpy.sum(FactNorm)
                     for i in range(spc.shape[0]):
                         '''****** Line of Data CSPC ******'''
                         cspcLine=cspc[i,:,Height].copy()
                         '''****** CSPC is normalized ******'''
                         chan_index0 = pairsList[i][0]
                         chan_index1 = pairsList[i][1]
                         CSPCFactor= abs(numpy.sum(ySamples[chan_index0]) * numpy.sum(ySamples[chan_index1])) #
                         CSPCNorm = (cspcLine.copy() -noise[i]) / numpy.sqrt(CSPCFactor)
                         CSPCSamples[i] = CSPCNorm
                         coherence[i] = numpy.abs(CSPCSamples[i]) / numpy.sqrt(CSPCFactor)
                         coherence[i]= self.moving_average(coherence[i],N=2)
                         phase[i] = self.moving_average( numpy.arctan2(CSPCSamples[i].imag, CSPCSamples[i].real),N=1)#*180/numpy.pi
-                    print 'cspcLine', cspcLine.shape, cspcLine[0:20]
+                    #print 'cspcLine', cspcLine.shape, cspcLine[0:20]
-                    print 'CSPCFactor', CSPCFactor#, CSPCFactor[0:20]
+                    #print 'CSPCFactor', CSPCFactor#, CSPCFactor[0:20]
-                    print numpy.sum(ySamples[chan_index0]), numpy.sum(ySamples[chan_index1]), -noise[i]
+                    #print numpy.sum(ySamples[chan_index0]), numpy.sum(ySamples[chan_index1]), -noise[i]
-                    print 'CSPCNorm', CSPCNorm.shape, CSPCNorm[0:20]
+                    #print 'CSPCNorm', CSPCNorm.shape, CSPCNorm[0:20]
-                    print 'CSPCNorm suma', numpy.sum(CSPCNorm)
+                    #print 'CSPCNorm suma', numpy.sum(CSPCNorm)
-                    print 'CSPCSamples', CSPCSamples.shape, CSPCSamples[0,0:20]
+                    #print 'CSPCSamples', CSPCSamples.shape, CSPCSamples[0,0:20]
                     '''****** Getting fij width ******'''
                     yMean=[]
                     yMean2=[]
                     for j in range(len(ySamples[1])):
                         yMean=numpy.append(yMean,numpy.mean([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 '****************************'
+                    #print '****************************'
-                    print 'len(xSamples): ',len(xSamples)
+                    #print 'len(xSamples): ',len(xSamples)
-                    print 'yMean: ', yMean.shape, yMean[0:20]
+                    #print 'yMean: ', yMean.shape, yMean[0:20]
-                    print 'ySamples', ySamples.shape, ySamples[0,0:20]
+                    #print 'ySamples', ySamples.shape, ySamples[0,0:20]
-                    print 'xSamples: ',xSamples.shape, xSamples[0:20]
+                    #print 'xSamples: ',xSamples.shape, xSamples[0:20]
-                    print 'meanGauss',meanGauss
+                    #print 'meanGauss',meanGauss
-                    print 'sigma',sigma
+                    #print 'sigma',sigma
                     #if (abs(meanGauss/sigma**2) > 0.0001) : #0.000000001):
-                    if dbSNR > SNRlimit :
+                    if dbSNR > SNRlimit and abs(meanGauss/sigma**2) > 0.0001:
                         try:
                             popt,pcov = curve_fit(self.gaus,xSamples,yMean,p0=[1,meanGauss,sigma])
                             if numpy.amax(popt)>numpy.amax(yMean)*0.3:
                                 FitGauss=self.gaus(xSamples,*popt)
                             else:
                                 FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
                                 print 'Verificador:     Dentro', Height
                         except :#RuntimeError:
                             FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
                     else:
                         FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
                     Maximun=numpy.amax(yMean)
                     eMinus1=Maximun*numpy.exp(-1)#*0.8
                     HWpos=self.Find(FitGauss,min(FitGauss, key=lambda value:abs(value-eMinus1)))
                     HalfWidth= xFrec[HWpos]
                     GCpos=self.Find(FitGauss, numpy.amax(FitGauss))
                     Vpos=self.Find(FactNorm, numpy.amax(FactNorm))
                     #Vpos=FirstMoment[]
                     '''****** 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=self.Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.10)))
                     if Rangpos<GCpos:
                         Range=numpy.array([Rangpos,2*GCpos-Rangpos])
                     elif Rangpos< ( len(xFrec)- len(xFrec)*0.1):
                         Range=numpy.array([2*GCpos-Rangpos,Rangpos])
                     else:
                         Range = numpy.array([0,0])
-                    print ' '
+                    #print ' '
-                    print 'GCpos',GCpos, ( len(xFrec)- len(xFrec)*0.1)
+                    #print 'GCpos',GCpos, ( len(xFrec)- len(xFrec)*0.1)
-                    print 'Rangpos',Rangpos
+                    #print 'Rangpos',Rangpos
                     print 'RANGE: ', Range
                     FrecRange=xFrec[Range[0]:Range[1]]
                     '''****** Getting SCPC Slope ******'''
                     for i in range(spc.shape[0]):
                         if len(FrecRange)>5 and len(FrecRange)<spc.shape[1]*0.5:
                             PhaseRange=self.moving_average(phase[i,Range[0]:Range[1]],N=3)
                             print 'FrecRange', len(FrecRange) , FrecRange
                             print 'PhaseRange', len(PhaseRange), PhaseRange
                             print ' '
                             if len(FrecRange) == len(PhaseRange):
                                 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
                         else:
                             PhaseSlope[i]=0
                             PhaseInter[i]=0
                         '''Getting constant C'''
                         cC=(Fij*numpy.pi)**2
                         '''****** 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)
                         Vver=xFrec[Vpos]
+                    print 'Height',Height
                     print 'vzon y vmer', Vzon, Vmer
-                    return Vzon, Vmer, Vver, GaussCenter
+                    return Vzon, Vmer, Vver, GaussCenter, PhaseSlope
             class SpectralMoments(Operation):
                 '''
                     Function SpectralMoments()
                     Calculates moments (power, mean, standard deviation) and SNR of the signal
                     Type of dataIn:    Spectra
                     Configuration Parameters:
                         dirCosx    :     Cosine director in X axis
                         dirCosy    :     Cosine director in Y axis
                         elevation  :
                         azimuth    :
                     Input:
                         channelList    :    simple channel list to select e.g. [2,3,7]
                         self.dataOut.data_pre        :    Spectral data
                         self.dataOut.abscissaList    :    List of frequencies
                         self.dataOut.noise           :    Noise level per channel
                     Affected:
                         self.dataOut.data_param      :    Parameters per channel
                         self.dataOut.data_SNR        :    SNR per channel
                 '''
                 def run(self, dataOut):
                     #dataOut.data_pre = dataOut.data_pre[0]
                     data = dataOut.data_pre[0]
                     absc = dataOut.abscissaList[:-1]
                     noise = dataOut.noise
                     nChannel = data.shape[0]
                     data_param = numpy.zeros((nChannel, 4, data.shape[2]))
                     for ind in range(nChannel):
                         data_param[ind,:,:] = self.__calculateMoments( data[ind,:,:] , absc , noise[ind] )
                     dataOut.data_param = data_param[:,1:,:]
                     dataOut.data_SNR = data_param[:,0]
                     return
                 def __calculateMoments(self, oldspec, oldfreq, n0,
                                        nicoh = None, graph = None, smooth = None, type1 = None, fwindow = None, snrth = None, dc = None, aliasing = None, oldfd = None, wwauto = None):
                     if (nicoh == None): nicoh = 1
                     if (graph == None): graph = 0
                     if (smooth == None): smooth = 0
                     elif (self.smooth < 3): smooth = 0
                     if (type1 == None): type1 = 0
                     if (fwindow == None): fwindow = numpy.zeros(oldfreq.size) + 1
                     if (snrth == None): snrth = -3
                     if (dc == None): dc = 0
                     if (aliasing == None): aliasing = 0
                     if (oldfd == None): oldfd = 0
                     if (wwauto == None): wwauto = 0
                     if (n0 < 1.e-20):   n0 = 1.e-20
                     freq = oldfreq
                     vec_power = numpy.zeros(oldspec.shape[1])
                     vec_fd = numpy.zeros(oldspec.shape[1])
                     vec_w = numpy.zeros(oldspec.shape[1])
                     vec_snr = numpy.zeros(oldspec.shape[1])
                     for ind in range(oldspec.shape[1]):
                         spec = oldspec[:,ind]
                         aux = spec*fwindow
                         max_spec = aux.max()
                         m = list(aux).index(max_spec)
                         #Smooth
                         if (smooth == 0):   spec2 = spec
                         else:   spec2 = scipy.ndimage.filters.uniform_filter1d(spec,size=smooth)
                         #    Calculo de Momentos
                         bb = spec2[range(m,spec2.size)]
                         bb = (bb<n0).nonzero()
                         bb = bb[0]
                         ss = spec2[range(0,m + 1)]
                         ss = (ss<n0).nonzero()
                         ss = ss[0]
                         if (bb.size == 0):
                             bb0 = spec.size - 1 - m
                         else:
                             bb0 = bb[0] - 1
                             if (bb0 < 0):
                                 bb0 = 0
                         if (ss.size == 0):   ss1 = 1
                         else: ss1 = max(ss) + 1
                         if (ss1 > m):   ss1 = m
                         valid = numpy.asarray(range(int(m + bb0 - ss1 + 1))) + ss1
                         power = ((spec2[valid] - n0)*fwindow[valid]).sum()
                         fd = ((spec2[valid]- n0)*freq[valid]*fwindow[valid]).sum()/power
                         w = math.sqrt(((spec2[valid] - n0)*fwindow[valid]*(freq[valid]- fd)**2).sum()/power)
                         snr = (spec2.mean()-n0)/n0
                         if (snr < 1.e-20) :
                             snr = 1.e-20
                         vec_power[ind] = power
                         vec_fd[ind] = fd
                         vec_w[ind] = w
                         vec_snr[ind] = snr
                     moments = numpy.vstack((vec_snr, vec_power, vec_fd, vec_w))
                     return moments
                 #------------------    Get SA Parameters    --------------------------
                 def GetSAParameters(self):
                     #SA en frecuencia
                     pairslist = self.dataOut.groupList
                     num_pairs = len(pairslist)
                     vel = self.dataOut.abscissaList
                     spectra = self.dataOut.data_pre
                     cspectra = self.dataIn.data_cspc
                     delta_v = vel[1] - vel[0]
                     #Calculating the power spectrum
                     spc_pow = numpy.sum(spectra, 3)*delta_v
                     #Normalizing Spectra
                     norm_spectra = spectra/spc_pow
                     #Calculating the norm_spectra at peak
                     max_spectra = numpy.max(norm_spectra, 3)
                     #Normalizing Cross Spectra
                     norm_cspectra = numpy.zeros(cspectra.shape)
                     for i in range(num_chan):
                         norm_cspectra[i,:,:] = cspectra[i,:,:]/numpy.sqrt(spc_pow[pairslist[i][0],:]*spc_pow[pairslist[i][1],:])
                     max_cspectra = numpy.max(norm_cspectra,2)
                     max_cspectra_index = numpy.argmax(norm_cspectra, 2)
                     for i in range(num_pairs):
                         cspc_par[i,:,:] = __calculateMoments(norm_cspectra)
                 #-------------------    Get Lags    ----------------------------------
             class SALags(Operation):
                 '''
                 Function GetMoments()
                 Input:
                     self.dataOut.data_pre
                     self.dataOut.abscissaList
                     self.dataOut.noise
                     self.dataOut.normFactor
                     self.dataOut.data_SNR
                     self.dataOut.groupList
                     self.dataOut.nChannels
                 Affected:
                     self.dataOut.data_param
                 '''
                 def run(self, dataOut):
                     data_acf = dataOut.data_pre[0]
                     data_ccf = dataOut.data_pre[1]
                     normFactor_acf = dataOut.normFactor[0]
                     normFactor_ccf = dataOut.normFactor[1]
                     pairs_acf = dataOut.groupList[0]
                     pairs_ccf = dataOut.groupList[1]
                     nHeights = dataOut.nHeights
                     absc = dataOut.abscissaList
                     noise = dataOut.noise
                     SNR = dataOut.data_SNR
                     nChannels = dataOut.nChannels
             #         pairsList = dataOut.groupList
             #         pairsAutoCorr, pairsCrossCorr = self.__getPairsAutoCorr(pairsList, nChannels)
                     for l in range(len(pairs_acf)):
                         data_acf[l,:,:] = data_acf[l,:,:]/normFactor_acf[l,:]
                     for l in range(len(pairs_ccf)):
                         data_ccf[l,:,:] = data_ccf[l,:,:]/normFactor_ccf[l,:]
                     dataOut.data_param = numpy.zeros((len(pairs_ccf)*2 + 1, nHeights))
                     dataOut.data_param[:-1,:] = self.__calculateTaus(data_acf, data_ccf, absc)
                     dataOut.data_param[-1,:] = self.__calculateLag1Phase(data_acf, absc)
                     return
             #     def __getPairsAutoCorr(self, pairsList, nChannels):
             #
             #         pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
             #
             #         for l in range(len(pairsList)):
             #             firstChannel = pairsList[l][0]
             #             secondChannel = pairsList[l][1]
             #
             #             #Obteniendo pares de Autocorrelacion
             #             if firstChannel == secondChannel:
             #                 pairsAutoCorr[firstChannel] = int(l)
             #
             #         pairsAutoCorr = pairsAutoCorr.astype(int)
             #
             #         pairsCrossCorr = range(len(pairsList))
             #         pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
             #
             #         return pairsAutoCorr, pairsCrossCorr
                 def __calculateTaus(self, data_acf, data_ccf, lagRange):
                     lag0 = data_acf.shape[1]/2
                     #Funcion de Autocorrelacion
                     mean_acf = stats.nanmean(data_acf, axis = 0)
                     #Obtencion Indice de TauCross
                     ind_ccf = data_ccf.argmax(axis = 1)
                     #Obtencion Indice de TauAuto
                     ind_acf = numpy.zeros(ind_ccf.shape,dtype = 'int')
                     ccf_lag0 = data_ccf[:,lag0,:]
                     for i in range(ccf_lag0.shape[0]):
                         ind_acf[i,:] = numpy.abs(mean_acf - ccf_lag0[i,:]).argmin(axis = 0)
                     #Obtencion de TauCross y TauAuto
                     tau_ccf = lagRange[ind_ccf]
                     tau_acf  = lagRange[ind_acf]
                     Nan1, Nan2 = numpy.where(tau_ccf == lagRange[0])
                     tau_ccf[Nan1,Nan2] = numpy.nan
                     tau_acf[Nan1,Nan2] = numpy.nan
                     tau = numpy.vstack((tau_ccf,tau_acf))
                     return tau
                 def __calculateLag1Phase(self, data, lagTRange):
                     data1 = stats.nanmean(data, axis = 0)
                     lag1 = numpy.where(lagTRange == 0)[0][0] + 1
                     phase = numpy.angle(data1[lag1,:])
                     return phase
             class SpectralFitting(Operation):
                 '''
                     Function GetMoments()
                     Input:
                     Output:
                     Variables modified:
                 '''
                 def run(self, dataOut, getSNR = True, path=None, file=None, groupList=None):
                     if path != None:
                         sys.path.append(path)
                     self.dataOut.library = importlib.import_module(file)
                     #To be inserted as a parameter
                     groupArray = numpy.array(groupList)
             #         groupArray = numpy.array([[0,1],[2,3]])
                     self.dataOut.groupList = groupArray
                     nGroups = groupArray.shape[0]
                     nChannels = self.dataIn.nChannels
                     nHeights=self.dataIn.heightList.size
                     #Parameters Array
                     self.dataOut.data_param = None
                     #Set constants
                     constants = self.dataOut.library.setConstants(self.dataIn)
                     self.dataOut.constants = constants
                     M = self.dataIn.normFactor
                     N = self.dataIn.nFFTPoints
                     ippSeconds = self.dataIn.ippSeconds
                     K = self.dataIn.nIncohInt
                     pairsArray = numpy.array(self.dataIn.pairsList)
                     #List of possible combinations
                     listComb = itertools.combinations(numpy.arange(groupArray.shape[1]),2)
                     indCross = numpy.zeros(len(list(listComb)), dtype = 'int')
                     if getSNR:
                         listChannels = groupArray.reshape((groupArray.size))
                         listChannels.sort()
                         noise = self.dataIn.getNoise()
                         self.dataOut.data_SNR = self.__getSNR(self.dataIn.data_spc[listChannels,:,:], noise[listChannels])
                     for i in range(nGroups):
                         coord = groupArray[i,:]
                         #Input data array
                         data = self.dataIn.data_spc[coord,:,:]/(M*N)
                         data = data.reshape((data.shape[0]*data.shape[1],data.shape[2]))
                         #Cross Spectra data array for Covariance Matrixes
                         ind = 0
                         for pairs in listComb:
                             pairsSel = numpy.array([coord[x],coord[y]])
                             indCross[ind] = int(numpy.where(numpy.all(pairsArray == pairsSel, axis = 1))[0][0])
                             ind += 1
                         dataCross = self.dataIn.data_cspc[indCross,:,:]/(M*N)
                         dataCross = dataCross**2/K
                         for h in range(nHeights):
             #                 print self.dataOut.heightList[h]
                             #Input
                             d = data[:,h]
                             #Covariance Matrix
                             D = numpy.diag(d**2/K)
                             ind = 0
                             for pairs in listComb:
                                 #Coordinates in Covariance Matrix
                                 x = pairs[0]
                                 y = pairs[1]
                                 #Channel Index
                                 S12 = dataCross[ind,:,h]
                                 D12 = numpy.diag(S12)
                                 #Completing Covariance Matrix with Cross Spectras
                                 D[x*N:(x+1)*N,y*N:(y+1)*N] = D12
                                 D[y*N:(y+1)*N,x*N:(x+1)*N] = D12
                                 ind += 1
                             Dinv=numpy.linalg.inv(D)
                             L=numpy.linalg.cholesky(Dinv)
                             LT=L.T
                             dp = numpy.dot(LT,d)
                             #Initial values
                             data_spc = self.dataIn.data_spc[coord,:,h]
                             if (h>0)and(error1[3]<5):
                                 p0 = self.dataOut.data_param[i,:,h-1]
                             else:
                                 p0 = numpy.array(self.dataOut.library.initialValuesFunction(data_spc, constants, i))
                             try:
                                 #Least Squares
                                 minp,covp,infodict,mesg,ier = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants),full_output=True)
             #                   minp,covp = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants))
                                 #Chi square error
                                 error0 = numpy.sum(infodict['fvec']**2)/(2*N)
                                 #Error with Jacobian
                                 error1 = self.dataOut.library.errorFunction(minp,constants,LT)
                             except:
                                 minp = p0*numpy.nan
                                 error0 = numpy.nan
                                 error1 = p0*numpy.nan
                             #Save
                             if self.dataOut.data_param == None:
                                 self.dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
                                 self.dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
                             self.dataOut.data_error[i,:,h] = numpy.hstack((error0,error1))
                             self.dataOut.data_param[i,:,h] = minp
                     return
                 def __residFunction(self, p, dp, LT, constants):
                     fm = self.dataOut.library.modelFunction(p, constants)
                     fmp=numpy.dot(LT,fm)
                     return  dp-fmp
                 def __getSNR(self, z, noise):
                     avg = numpy.average(z, axis=1)
                     SNR = (avg.T-noise)/noise
                     SNR = SNR.T
                     return SNR
                 def __chisq(p,chindex,hindex):
                     #similar to Resid but calculates CHI**2
                     [LT,d,fm]=setupLTdfm(p,chindex,hindex)
                     dp=numpy.dot(LT,d)
                     fmp=numpy.dot(LT,fm)
                     chisq=numpy.dot((dp-fmp).T,(dp-fmp))
                     return chisq
             class WindProfiler(Operation):
                 __isConfig = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 __firstdata = None
                 n = None
                 def __init__(self):
                     Operation.__init__(self)
                 def __calculateCosDir(self, elev, azim):
                     zen = (90 - elev)*numpy.pi/180
                     azim = azim*numpy.pi/180
                     cosDirX = numpy.sqrt((1-numpy.cos(zen)**2)/((1+numpy.tan(azim)**2)))
                     cosDirY = numpy.sqrt(1-numpy.cos(zen)**2-cosDirX**2)
                     signX = numpy.sign(numpy.cos(azim))
                     signY = numpy.sign(numpy.sin(azim))
                     cosDirX = numpy.copysign(cosDirX, signX)
                     cosDirY = numpy.copysign(cosDirY, signY)
                     return cosDirX, cosDirY
                 def __calculateAngles(self, theta_x, theta_y, azimuth):
                     dir_cosw = numpy.sqrt(1-theta_x**2-theta_y**2)
                     zenith_arr = numpy.arccos(dir_cosw)
                     azimuth_arr = numpy.arctan2(theta_x,theta_y) + azimuth*math.pi/180
                     dir_cosu = numpy.sin(azimuth_arr)*numpy.sin(zenith_arr)
                     dir_cosv = numpy.cos(azimuth_arr)*numpy.sin(zenith_arr)
                     return azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw
                 def __calculateMatA(self, dir_cosu, dir_cosv, dir_cosw, horOnly):
             #
                     if horOnly:
                         A = numpy.c_[dir_cosu,dir_cosv]
                     else:
                         A = numpy.c_[dir_cosu,dir_cosv,dir_cosw]
                     A = numpy.asmatrix(A)
                     A1 = numpy.linalg.inv(A.transpose()*A)*A.transpose()
                     return A1
                 def __correctValues(self, heiRang, phi, velRadial, SNR):
                     listPhi = phi.tolist()
                     maxid = listPhi.index(max(listPhi))
                     minid = listPhi.index(min(listPhi))
                     rango = range(len(phi))
                #     rango = numpy.delete(rango,maxid)
                     heiRang1 = heiRang*math.cos(phi[maxid])
                     heiRangAux = heiRang*math.cos(phi[minid])
                     indOut = (heiRang1 < heiRangAux[0]).nonzero()
                     heiRang1 = numpy.delete(heiRang1,indOut)
                     velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
                     SNR1 = numpy.zeros([len(phi),len(heiRang1)])
                     for i in rango:
                         x = heiRang*math.cos(phi[i])
                         y1 = velRadial[i,:]
                         f1 = interpolate.interp1d(x,y1,kind = 'cubic')
                         x1 = heiRang1
                         y11 = f1(x1)
                         y2 = SNR[i,:]
                         f2 = interpolate.interp1d(x,y2,kind = 'cubic')
                         y21 = f2(x1)
                         velRadial1[i,:] = y11
                         SNR1[i,:] = y21
                     return heiRang1, velRadial1, SNR1
                 def __calculateVelUVW(self, A, velRadial):
                     #Operacion Matricial
             #         velUVW = numpy.zeros((velRadial.shape[1],3))
             #         for ind in range(velRadial.shape[1]):
             #             velUVW[ind,:] = numpy.dot(A,velRadial[:,ind])
             #         velUVW = velUVW.transpose()
                     velUVW = numpy.zeros((A.shape[0],velRadial.shape[1]))
                     velUVW[:,:] = numpy.dot(A,velRadial)
                     return velUVW
             #     def techniqueDBS(self, velRadial0, dirCosx, disrCosy, azimuth, correct, horizontalOnly, heiRang, SNR0):
                 def techniqueDBS(self, kwargs):
                     """
                     Function that implements Doppler Beam Swinging (DBS) technique.
                     Input:    Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
                                 Direction correction (if necessary), Ranges and SNR
                     Output:    Winds estimation (Zonal, Meridional and Vertical)
                     Parameters affected:    Winds, height range, SNR
                     """
                     velRadial0 = kwargs['velRadial']
                     heiRang = kwargs['heightList']
                     SNR0 = kwargs['SNR']
                     if kwargs.has_key('dirCosx') and kwargs.has_key('dirCosy'):
                         theta_x = numpy.array(kwargs['dirCosx'])
                         theta_y = numpy.array(kwargs['dirCosy'])
                     else:
                         elev = numpy.array(kwargs['elevation'])
                         azim = numpy.array(kwargs['azimuth'])
                         theta_x, theta_y = self.__calculateCosDir(elev, azim)
                     azimuth = kwargs['correctAzimuth']
                     if kwargs.has_key('horizontalOnly'):
                         horizontalOnly = kwargs['horizontalOnly']
                     else:   horizontalOnly = False
                     if kwargs.has_key('correctFactor'):
                         correctFactor = kwargs['correctFactor']
                     else:   correctFactor = 1
                     if kwargs.has_key('channelList'):
                         channelList = kwargs['channelList']
                         if len(channelList) == 2:
                             horizontalOnly = True
                         arrayChannel = numpy.array(channelList)
                         param = param[arrayChannel,:,:]
                         theta_x = theta_x[arrayChannel]
                         theta_y = theta_y[arrayChannel]
                     azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
                     heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, zenith_arr, correctFactor*velRadial0, SNR0)
                     A = self.__calculateMatA(dir_cosu, dir_cosv, dir_cosw, horizontalOnly)
                     #Calculo de Componentes de la velocidad con DBS
                     winds = self.__calculateVelUVW(A,velRadial1)
                     return winds, heiRang1, SNR1
                 def __calculateDistance(self, posx, posy, pairs_ccf, azimuth = None):
                     nPairs = len(pairs_ccf)
                     posx = numpy.asarray(posx)
                     posy = numpy.asarray(posy)
                     #Rotacion Inversa para alinear con el azimuth
                     if azimuth!= None:
                         azimuth = azimuth*math.pi/180
                         posx1 = posx*math.cos(azimuth) + posy*math.sin(azimuth)
                         posy1 = -posx*math.sin(azimuth) + posy*math.cos(azimuth)
                     else:
                         posx1 = posx
                         posy1 = posy
                     #Calculo de Distancias
                     distx = numpy.zeros(nPairs)
                     disty = numpy.zeros(nPairs)
                     dist = numpy.zeros(nPairs)
                     ang = numpy.zeros(nPairs)
                     for i in range(nPairs):
                         distx[i] = posx1[pairs_ccf[i][1]] - posx1[pairs_ccf[i][0]]
                         disty[i] = posy1[pairs_ccf[i][1]] - posy1[pairs_ccf[i][0]]
                         dist[i] = numpy.sqrt(distx[i]**2 + disty[i]**2)
                         ang[i] = numpy.arctan2(disty[i],distx[i])
                     return distx, disty, dist, ang
                     #Calculo de Matrices
             #         nPairs = len(pairs)
             #         ang1 = numpy.zeros((nPairs, 2, 1))
             #         dist1 = numpy.zeros((nPairs, 2, 1))
             #
             #         for j in range(nPairs):
             #             dist1[j,0,0] = dist[pairs[j][0]]
             #             dist1[j,1,0] = dist[pairs[j][1]]
             #             ang1[j,0,0] = ang[pairs[j][0]]
             #             ang1[j,1,0] = ang[pairs[j][1]]
             #
             #         return distx,disty, dist1,ang1
                 def __calculateVelVer(self, phase, lagTRange, _lambda):
                     Ts = lagTRange[1] - lagTRange[0]
                     velW = -_lambda*phase/(4*math.pi*Ts)
                     return velW
                 def __calculateVelHorDir(self, dist, tau1, tau2, ang):
                     nPairs = tau1.shape[0]
                     nHeights = tau1.shape[1]
                     vel = numpy.zeros((nPairs,3,nHeights))
                     dist1 = numpy.reshape(dist, (dist.size,1))
                     angCos = numpy.cos(ang)
                     angSin = numpy.sin(ang)
                     vel0 = dist1*tau1/(2*tau2**2)
                     vel[:,0,:] = (vel0*angCos).sum(axis = 1)
                     vel[:,1,:] = (vel0*angSin).sum(axis = 1)
                     ind = numpy.where(numpy.isinf(vel))
                     vel[ind] = numpy.nan
                     return vel
             #     def __getPairsAutoCorr(self, pairsList, nChannels):
             #
             #         pairsAutoCorr = numpy.zeros(nChannels, dtype = 'int')*numpy.nan
             #
             #         for l in range(len(pairsList)):
             #             firstChannel = pairsList[l][0]
             #             secondChannel = pairsList[l][1]
             #
             #             #Obteniendo pares de Autocorrelacion
             #             if firstChannel == secondChannel:
             #                 pairsAutoCorr[firstChannel] = int(l)
             #
             #         pairsAutoCorr = pairsAutoCorr.astype(int)
             #
             #         pairsCrossCorr = range(len(pairsList))
             #         pairsCrossCorr = numpy.delete(pairsCrossCorr,pairsAutoCorr)
             #
             #         return pairsAutoCorr, pairsCrossCorr
             #     def techniqueSA(self, pairsSelected, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, lagTRange, correctFactor):
                 def techniqueSA(self, kwargs):
                     """
                     Function that implements Spaced Antenna (SA) technique.
                     Input:    Radial velocities, Direction cosines (x and y) of the Beam, Antenna azimuth,
                                 Direction correction (if necessary), Ranges and SNR
                     Output:    Winds estimation (Zonal, Meridional and Vertical)
                     Parameters affected:    Winds
                     """
                     position_x = kwargs['positionX']
                     position_y = kwargs['positionY']
                     azimuth = kwargs['azimuth']
                     if kwargs.has_key('correctFactor'):
                         correctFactor = kwargs['correctFactor']
                     else:
                         correctFactor = 1
                     groupList = kwargs['groupList']
                     pairs_ccf = groupList[1]
                     tau = kwargs['tau']
                     _lambda = kwargs['_lambda']
                     #Cross Correlation pairs obtained
             #         pairsAutoCorr, pairsCrossCorr = self.__getPairsAutoCorr(pairssList, nChannels)
             #         pairsArray = numpy.array(pairsList)[pairsCrossCorr]
             #         pairsSelArray = numpy.array(pairsSelected)
             #         pairs = []
             #
             #         #Wind estimation pairs obtained
             #         for i in range(pairsSelArray.shape[0]/2):
             #             ind1 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i], axis = 1))[0][0]
             #             ind2 = numpy.where(numpy.all(pairsArray == pairsSelArray[2*i + 1], axis = 1))[0][0]
             #             pairs.append((ind1,ind2))
                     indtau = tau.shape[0]/2
                     tau1 = tau[:indtau,:]
                     tau2 = tau[indtau:-1,:]
             #         tau1 = tau1[pairs,:]
             #         tau2 = tau2[pairs,:]
                     phase1 = tau[-1,:]
                     #---------------------------------------------------------------------
                     #Metodo Directo
                     distx, disty, dist, ang = self.__calculateDistance(position_x, position_y, pairs_ccf,azimuth)
                     winds = self.__calculateVelHorDir(dist, tau1, tau2, ang)
                     winds = stats.nanmean(winds, axis=0)
                     #---------------------------------------------------------------------
                     #Metodo General
             #         distx, disty, dist = self.calculateDistance(position_x,position_y,pairsCrossCorr, pairsList, azimuth)
             #         #Calculo Coeficientes de Funcion de Correlacion
             #         F,G,A,B,H = self.calculateCoef(tau1,tau2,distx,disty,n)
             #         #Calculo de Velocidades
             #         winds = self.calculateVelUV(F,G,A,B,H)
                     #---------------------------------------------------------------------
                     winds[2,:] = self.__calculateVelVer(phase1, lagTRange, _lambda)
                     winds = correctFactor*winds
                     return winds
                 def __checkTime(self, currentTime, paramInterval, outputInterval):
                     dataTime = currentTime + paramInterval
                     deltaTime = dataTime - self.__initime
                     if deltaTime >= outputInterval or deltaTime < 0:
                         self.__dataReady = True
                     return
                 def techniqueMeteors(self, arrayMeteor, meteorThresh, heightMin, heightMax):
                     '''
                     Function that implements winds estimation technique with detected meteors.
                     Input:    Detected meteors, Minimum meteor quantity to wind estimation
                     Output:    Winds estimation (Zonal and Meridional)
                     Parameters affected:    Winds
                     '''
             #         print arrayMeteor.shape
                     #Settings
                     nInt = (heightMax - heightMin)/2
             #         print nInt
                     nInt = int(nInt)
             #         print nInt
                     winds = numpy.zeros((2,nInt))*numpy.nan
                     #Filter errors
                     error = numpy.where(arrayMeteor[:,-1] == 0)[0]
                     finalMeteor = arrayMeteor[error,:]
                     #Meteor Histogram
                     finalHeights = finalMeteor[:,2]
                     hist = numpy.histogram(finalHeights, bins = nInt, range = (heightMin,heightMax))
                     nMeteorsPerI = hist[0]
                     heightPerI = hist[1]
                     #Sort of meteors
                     indSort = finalHeights.argsort()
                     finalMeteor2 = finalMeteor[indSort,:]
                     #    Calculating winds
                     ind1 = 0
                     ind2 = 0
                     for i in range(nInt):
                         nMet = nMeteorsPerI[i]
                         ind1 = ind2
                         ind2 = ind1 + nMet
                         meteorAux = finalMeteor2[ind1:ind2,:]
                         if meteorAux.shape[0] >= meteorThresh:
                             vel = meteorAux[:, 6]
                             zen = meteorAux[:, 4]*numpy.pi/180
                             azim = meteorAux[:, 3]*numpy.pi/180
                             n = numpy.cos(zen)
                     #         m = (1 - n**2)/(1 - numpy.tan(azim)**2)
                     #         l = m*numpy.tan(azim)
                             l = numpy.sin(zen)*numpy.sin(azim)
                             m = numpy.sin(zen)*numpy.cos(azim)
                             A = numpy.vstack((l, m)).transpose()
                             A1 = numpy.dot(numpy.linalg.inv( numpy.dot(A.transpose(),A) ),A.transpose())
                             windsAux = numpy.dot(A1, vel)
                             winds[0,i] = windsAux[0]
                             winds[1,i] = windsAux[1]
                     return winds, heightPerI[:-1]
                 def techniqueNSM_SA(self, **kwargs):
                     metArray = kwargs['metArray']
                     heightList = kwargs['heightList']
                     timeList = kwargs['timeList']
                     rx_location = kwargs['rx_location']
                     groupList = kwargs['groupList']
                     azimuth = kwargs['azimuth']
                     dfactor = kwargs['dfactor']
                     k = kwargs['k']
                     azimuth1, dist = self.__calculateAzimuth1(rx_location, groupList, azimuth)
                     d = dist*dfactor
                     #Phase calculation
                     metArray1 = self.__getPhaseSlope(metArray, heightList, timeList)
                     metArray1[:,-2] = metArray1[:,-2]*metArray1[:,2]*1000/(k*d[metArray1[:,1].astype(int)]) #angles into velocities
                     velEst = numpy.zeros((heightList.size,2))*numpy.nan
                     azimuth1 = azimuth1*numpy.pi/180
                     for i in range(heightList.size):
                         h = heightList[i]
                         indH = numpy.where((metArray1[:,2] == h)&(numpy.abs(metArray1[:,-2]) < 100))[0]
                         metHeight = metArray1[indH,:]
                         if metHeight.shape[0] >= 2:
                             velAux = numpy.asmatrix(metHeight[:,-2]).T    #Radial Velocities
                             iazim = metHeight[:,1].astype(int)
                             azimAux = numpy.asmatrix(azimuth1[iazim]).T    #Azimuths
                             A = numpy.hstack((numpy.cos(azimAux),numpy.sin(azimAux)))
                             A = numpy.asmatrix(A)
                             A1 = numpy.linalg.pinv(A.transpose()*A)*A.transpose()
                             velHor = numpy.dot(A1,velAux)
                             velEst[i,:] = numpy.squeeze(velHor)
                     return velEst
                 def __getPhaseSlope(self, metArray, heightList, timeList):
                     meteorList = []
                     #utctime sec1 height SNR velRad ph0 ph1 ph2 coh0 coh1 coh2
                     #Putting back together the meteor matrix
                     utctime = metArray[:,0]
                     uniqueTime = numpy.unique(utctime)
                     phaseDerThresh = 0.5
                     ippSeconds = timeList[1] - timeList[0]
                     sec = numpy.where(timeList>1)[0][0]
                     nPairs = metArray.shape[1] - 6
                     nHeights = len(heightList)
                     for t in uniqueTime:
                         metArray1 = metArray[utctime==t,:]
             #         phaseDerThresh = numpy.pi/4 #reducir Phase thresh
                         tmet = metArray1[:,1].astype(int)
                         hmet = metArray1[:,2].astype(int)
                         metPhase = numpy.zeros((nPairs, heightList.size, timeList.size - 1))
                         metPhase[:,:] = numpy.nan
                         metPhase[:,hmet,tmet] = metArray1[:,6:].T
                         #Delete short trails
                         metBool = ~numpy.isnan(metPhase[0,:,:])
                         heightVect = numpy.sum(metBool, axis = 1)
                         metBool[heightVect<sec,:] = False
                         metPhase[:,heightVect<sec,:] = numpy.nan
                         #Derivative
                         metDer = numpy.abs(metPhase[:,:,1:] - metPhase[:,:,:-1])
                         phDerAux = numpy.dstack((numpy.full((nPairs,nHeights,1), False, dtype=bool),metDer > phaseDerThresh))
                         metPhase[phDerAux] = numpy.nan
                         #--------------------------METEOR DETECTION    -----------------------------------------
                         indMet = numpy.where(numpy.any(metBool,axis=1))[0]
                         for p in numpy.arange(nPairs):
                             phase = metPhase[p,:,:]
                             phDer = metDer[p,:,:]
                             for h in indMet:
                                 height = heightList[h]
                                 phase1 = phase[h,:] #82
                                 phDer1 = phDer[h,:]
                                 phase1[~numpy.isnan(phase1)] = numpy.unwrap(phase1[~numpy.isnan(phase1)])   #Unwrap
                                 indValid = numpy.where(~numpy.isnan(phase1))[0]
                                 initMet = indValid[0]
                                 endMet = 0
                                 for i in range(len(indValid)-1):
                                     #Time difference
                                     inow = indValid[i]
                                     inext = indValid[i+1]
                                     idiff = inext - inow
                                     #Phase difference
                                     phDiff = numpy.abs(phase1[inext] - phase1[inow])
                                     if idiff>sec or phDiff>numpy.pi/4 or inext==indValid[-1]:   #End of Meteor
                                         sizeTrail = inow - initMet + 1
                                         if sizeTrail>3*sec:  #Too short meteors
                                             x = numpy.arange(initMet,inow+1)*ippSeconds
                                             y = phase1[initMet:inow+1]
                                             ynnan = ~numpy.isnan(y)
                                             x = x[ynnan]
                                             y = y[ynnan]
                                             slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)
                                             ylin = x*slope + intercept
                                             rsq = r_value**2
                                             if rsq > 0.5:
                                                 vel = slope#*height*1000/(k*d)
                                                 estAux = numpy.array([utctime,p,height, vel, rsq])
                                                 meteorList.append(estAux)
                                         initMet = inext
                     metArray2 = numpy.array(meteorList)
                     return metArray2
                 def __calculateAzimuth1(self, rx_location, pairslist, azimuth0):
                     azimuth1 = numpy.zeros(len(pairslist))
                     dist = numpy.zeros(len(pairslist))
                     for i in range(len(rx_location)):
                         ch0 = pairslist[i][0]
                         ch1 = pairslist[i][1]
                         diffX = rx_location[ch0][0] - rx_location[ch1][0]
                         diffY = rx_location[ch0][1] - rx_location[ch1][1]
                         azimuth1[i] = numpy.arctan2(diffY,diffX)*180/numpy.pi
                         dist[i] = numpy.sqrt(diffX**2 + diffY**2)
                     azimuth1 -= azimuth0
                     return azimuth1, dist
                 def techniqueNSM_DBS(self, **kwargs):
                     metArray = kwargs['metArray']
                     heightList = kwargs['heightList']
                     timeList = kwargs['timeList']
                     zenithList = kwargs['zenithList']
                     nChan = numpy.max(cmet) + 1
                     nHeights = len(heightList)
                     utctime = metArray[:,0]
                     cmet = metArray[:,1]
                     hmet = metArray1[:,3].astype(int)
                     h1met = heightList[hmet]*zenithList[cmet]
                     vmet = metArray1[:,5]
                     for i in range(nHeights - 1):
                         hmin = heightList[i]
                         hmax = heightList[i + 1]
                         vthisH = vmet[(h1met>=hmin) & (h1met<hmax)]
                     return data_output
                 def run(self, dataOut, technique, **kwargs):
                     param = dataOut.data_param
                     if dataOut.abscissaList != None:
                         absc = dataOut.abscissaList[:-1]
                     noise = dataOut.noise
                     heightList = dataOut.heightList
                     SNR = dataOut.data_SNR
                     if technique == 'DBS':
                         kwargs['velRadial'] = param[:,1,:] #Radial velocity
                         kwargs['heightList'] = heightList
                         kwargs['SNR'] = SNR
                         dataOut.data_output, dataOut.heightList, dataOut.data_SNR = self.techniqueDBS(kwargs) #DBS Function
                         dataOut.utctimeInit = dataOut.utctime
                         dataOut.outputInterval = dataOut.paramInterval
                     elif technique == 'SA':
                         #Parameters
             #             position_x = kwargs['positionX']
             #             position_y = kwargs['positionY']
             #             azimuth = kwargs['azimuth']
             #
             #             if kwargs.has_key('crosspairsList'):
             #                 pairs = kwargs['crosspairsList']
             #             else:
             #                 pairs = None
             #
             #             if kwargs.has_key('correctFactor'):
             #                 correctFactor = kwargs['correctFactor']
             #             else:
             #                 correctFactor = 1
             #             tau = dataOut.data_param
             #             _lambda = dataOut.C/dataOut.frequency
             #             pairsList = dataOut.groupList
             #             nChannels = dataOut.nChannels
                         kwargs['groupList'] = dataOut.groupList
                         kwargs['tau'] = dataOut.data_param
                         kwargs['_lambda'] = dataOut.C/dataOut.frequency
             #             dataOut.data_output = self.techniqueSA(pairs, pairsList, nChannels, tau, azimuth, _lambda, position_x, position_y, absc, correctFactor)
                         dataOut.data_output = self.techniqueSA(kwargs)
                         dataOut.utctimeInit = dataOut.utctime
                         dataOut.outputInterval = dataOut.timeInterval
                     elif technique == 'Meteors':
                         dataOut.flagNoData = True
                         self.__dataReady = False
                         if kwargs.has_key('nHours'):
                             nHours = kwargs['nHours']
                         else:
                             nHours = 1
                         if kwargs.has_key('meteorsPerBin'):
                             meteorThresh = kwargs['meteorsPerBin']
                         else:
                             meteorThresh = 6
                         if kwargs.has_key('hmin'):
                             hmin = kwargs['hmin']
                         else:   hmin = 70
                         if kwargs.has_key('hmax'):
                             hmax = kwargs['hmax']
                         else:   hmax = 110
                         dataOut.outputInterval = nHours*3600
                         if self.__isConfig == False:
             #                 self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
                             #Get Initial LTC time
                             self.__initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
                             self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
                             self.__isConfig = True
                         if self.__buffer == None:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                         else:
                             self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
                         self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
                         if self.__dataReady:
                             dataOut.utctimeInit = self.__initime
                             self.__initime += dataOut.outputInterval #to erase time offset
                             dataOut.data_output, dataOut.heightList = self.techniqueMeteors(self.__buffer, meteorThresh, hmin, hmax)
                             dataOut.flagNoData = False
                             self.__buffer = None
                     elif technique == 'Meteors1':
                         dataOut.flagNoData = True
                         self.__dataReady = False
                         if kwargs.has_key('nMins'):
                             nMins = kwargs['nMins']
                         else: nMins = 20
                         if kwargs.has_key('rx_location'):
                             rx_location = kwargs['rx_location']
                         else: rx_location = [(0,1),(1,1),(1,0)]
                         if kwargs.has_key('azimuth'):
                             azimuth = kwargs['azimuth']
                         else: azimuth = 51
                         if kwargs.has_key('dfactor'):
                             dfactor = kwargs['dfactor']
                         if kwargs.has_key('mode'):
                             mode = kwargs['mode']
                         else: mode = 'SA'
                         #Borrar luego esto
                         if dataOut.groupList == None:
                             dataOut.groupList = [(0,1),(0,2),(1,2)]
                         groupList = dataOut.groupList
                         C = 3e8
                         freq = 50e6
                         lamb = C/freq
                         k = 2*numpy.pi/lamb
                         timeList = dataOut.abscissaList
                         heightList = dataOut.heightList
                         if self.__isConfig == False:
                             dataOut.outputInterval = nMins*60
             #                 self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
                             #Get Initial LTC time
                             initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
                             minuteAux = initime.minute
                             minuteNew = int(numpy.floor(minuteAux/nMins)*nMins)
                             self.__initime = (initime.replace(minute = minuteNew, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
                             self.__isConfig = True
                         if self.__buffer == None:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                         else:
                             self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
                         self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
                         if self.__dataReady:
                             dataOut.utctimeInit = self.__initime
                             self.__initime += dataOut.outputInterval #to erase time offset
                             metArray = self.__buffer
                             if mode == 'SA':
                                 dataOut.data_output = self.techniqueNSM_SA(rx_location=rx_location, groupList=groupList, azimuth=azimuth, dfactor=dfactor, k=k,metArray=metArray, heightList=heightList,timeList=timeList)
                             elif mode == 'DBS':
                                 dataOut.data_output = self.techniqueNSM_DBS(metArray=metArray,heightList=heightList,timeList=timeList)
                             dataOut.data_output = dataOut.data_output.T
                             dataOut.flagNoData = False
                             self.__buffer = None
                     return
             class EWDriftsEstimation(Operation):
                 def __init__(self):
                     Operation.__init__(self)
                 def __correctValues(self, heiRang, phi, velRadial, SNR):
                     listPhi = phi.tolist()
                     maxid = listPhi.index(max(listPhi))
                     minid = listPhi.index(min(listPhi))
                     rango = range(len(phi))
                #     rango = numpy.delete(rango,maxid)
                     heiRang1 = heiRang*math.cos(phi[maxid])
                     heiRangAux = heiRang*math.cos(phi[minid])
                     indOut = (heiRang1 < heiRangAux[0]).nonzero()
                     heiRang1 = numpy.delete(heiRang1,indOut)
                     velRadial1 = numpy.zeros([len(phi),len(heiRang1)])
                     SNR1 = numpy.zeros([len(phi),len(heiRang1)])
                     for i in rango:
                         x = heiRang*math.cos(phi[i])
                         y1 = velRadial[i,:]
                         f1 = interpolate.interp1d(x,y1,kind = 'cubic')
                         x1 = heiRang1
                         y11 = f1(x1)
                         y2 = SNR[i,:]
                         f2 = interpolate.interp1d(x,y2,kind = 'cubic')
                         y21 = f2(x1)
                         velRadial1[i,:] = y11
                         SNR1[i,:] = y21
                     return heiRang1, velRadial1, SNR1
                 def run(self, dataOut, zenith, zenithCorrection):
                     heiRang = dataOut.heightList
                     velRadial = dataOut.data_param[:,3,:]
                     SNR = dataOut.data_SNR
                     zenith = numpy.array(zenith)
                     zenith -= zenithCorrection
                     zenith *= numpy.pi/180
                     heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, numpy.abs(zenith), velRadial, SNR)
                     alp = zenith[0]
                     bet = zenith[1]
                     w_w = velRadial1[0,:]
                     w_e = velRadial1[1,:]
                     w = (w_w*numpy.sin(bet) - w_e*numpy.sin(alp))/(numpy.cos(alp)*numpy.sin(bet) - numpy.cos(bet)*numpy.sin(alp))
                     u = (w_w*numpy.cos(bet) - w_e*numpy.cos(alp))/(numpy.sin(alp)*numpy.cos(bet) - numpy.sin(bet)*numpy.cos(alp))
                     winds = numpy.vstack((u,w))
                     dataOut.heightList = heiRang1
                     dataOut.data_output = winds
                     dataOut.data_SNR = SNR1
                     dataOut.utctimeInit = dataOut.utctime
                     dataOut.outputInterval = dataOut.timeInterval
                     return
             #---------------    Non Specular Meteor    ----------------
             class NonSpecularMeteorDetection(Operation):
                 def run(self, mode, SNRthresh=8, phaseDerThresh=0.5, cohThresh=0.8, allData = False):
                     data_acf = self.dataOut.data_pre[0]
                     data_ccf = self.dataOut.data_pre[1]
                     lamb = self.dataOut.C/self.dataOut.frequency
                     tSamp = self.dataOut.ippSeconds*self.dataOut.nCohInt
                     paramInterval = self.dataOut.paramInterval
                     nChannels = data_acf.shape[0]
                     nLags = data_acf.shape[1]
                     nProfiles = data_acf.shape[2]
                     nHeights = self.dataOut.nHeights
                     nCohInt = self.dataOut.nCohInt
                     sec = numpy.round(nProfiles/self.dataOut.paramInterval)
                     heightList = self.dataOut.heightList
                     ippSeconds = self.dataOut.ippSeconds*self.dataOut.nCohInt*self.dataOut.nAvg
                     utctime = self.dataOut.utctime
                     self.dataOut.abscissaList = numpy.arange(0,paramInterval+ippSeconds,ippSeconds)
                     #------------------------    SNR    --------------------------------------
                     power = data_acf[:,0,:,:].real
                     noise = numpy.zeros(nChannels)
                     SNR = numpy.zeros(power.shape)
                     for i in range(nChannels):
                         noise[i] = hildebrand_sekhon(power[i,:], nCohInt)
                         SNR[i] = (power[i]-noise[i])/noise[i]
                     SNRm = numpy.nanmean(SNR, axis = 0)
                     SNRdB = 10*numpy.log10(SNR)
                     if mode == 'SA':
                         nPairs = data_ccf.shape[0]
                         #----------------------    Coherence and Phase   --------------------------
                         phase = numpy.zeros(data_ccf[:,0,:,:].shape)
             #             phase1 = numpy.copy(phase)
                         coh1 = numpy.zeros(data_ccf[:,0,:,:].shape)
                         for p in range(nPairs):
                             ch0 = self.dataOut.groupList[p][0]
                             ch1 = self.dataOut.groupList[p][1]
                             ccf = data_ccf[p,0,:,:]/numpy.sqrt(data_acf[ch0,0,:,:]*data_acf[ch1,0,:,:])
                             phase[p,:,:] = ndimage.median_filter(numpy.angle(ccf), size = (5,1)) #median filter
             #                 phase1[p,:,:] = numpy.angle(ccf) #median filter
                             coh1[p,:,:] = ndimage.median_filter(numpy.abs(ccf), 5) #median filter
             #                 coh1[p,:,:] = numpy.abs(ccf) #median filter
                         coh = numpy.nanmax(coh1, axis = 0)
             #             struc = numpy.ones((5,1))
             #             coh = ndimage.morphology.grey_dilation(coh, size=(10,1))
                         #----------------------    Radial Velocity    ----------------------------
                         phaseAux = numpy.mean(numpy.angle(data_acf[:,1,:,:]), axis = 0)
                         velRad = phaseAux*lamb/(4*numpy.pi*tSamp)
                         if allData:
                             boolMetFin = ~numpy.isnan(SNRm)
             #                 coh[:-1,:] = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
                         else:
                             #------------------------    Meteor mask    ---------------------------------
             #                 #SNR mask
             #                 boolMet = (SNRdB>SNRthresh)#|(~numpy.isnan(SNRdB))
             #
             #                 #Erase small objects
             #                 boolMet1 = self.__erase_small(boolMet, 2*sec, 5)
             #
             #                 auxEEJ = numpy.sum(boolMet1,axis=0)
             #                 indOver = auxEEJ>nProfiles*0.8  #Use this later
             #                 indEEJ = numpy.where(indOver)[0]
             #                 indNEEJ = numpy.where(~indOver)[0]
             #
             #                 boolMetFin = boolMet1
             #
             #                 if indEEJ.size > 0:
             #                     boolMet1[:,indEEJ] = False  #Erase heights with EEJ
             #
             #                     boolMet2 = coh > cohThresh
             #                     boolMet2 = self.__erase_small(boolMet2, 2*sec,5)
             #
             #                     #Final Meteor mask
             #                     boolMetFin = boolMet1|boolMet2
                             #Coherence mask
                             boolMet1 = coh > 0.75
                             struc = numpy.ones((30,1))
                             boolMet1 = ndimage.morphology.binary_dilation(boolMet1, structure=struc)
                             #Derivative mask
                             derPhase = numpy.nanmean(numpy.abs(phase[:,1:,:] - phase[:,:-1,:]),axis=0)
                             boolMet2 = derPhase < 0.2
             #                 boolMet2 = ndimage.morphology.binary_opening(boolMet2)
             #                 boolMet2 = ndimage.morphology.binary_closing(boolMet2, structure = numpy.ones((10,1)))
                             boolMet2 = ndimage.median_filter(boolMet2,size=5)
                             boolMet2 = numpy.vstack((boolMet2,numpy.full((1,nHeights), True, dtype=bool)))
             #                 #Final mask
             #                 boolMetFin = boolMet2
                             boolMetFin = boolMet1&boolMet2
             #                 boolMetFin = ndimage.morphology.binary_dilation(boolMetFin)
                         #Creating data_param
                         coordMet = numpy.where(boolMetFin)
                         tmet = coordMet[0]
                         hmet = coordMet[1]
                         data_param = numpy.zeros((tmet.size, 6 + nPairs))
                         data_param[:,0] = utctime
                         data_param[:,1] = tmet
                         data_param[:,2] = hmet
                         data_param[:,3] = SNRm[tmet,hmet]
                         data_param[:,4] = velRad[tmet,hmet]
                         data_param[:,5] = coh[tmet,hmet]
                         data_param[:,6:] = phase[:,tmet,hmet].T
                     elif mode == 'DBS':
                         self.dataOut.groupList = numpy.arange(nChannels)
                         #Radial Velocities
             #             phase = numpy.angle(data_acf[:,1,:,:])
                         phase = ndimage.median_filter(numpy.angle(data_acf[:,1,:,:]), size = (1,5,1))
                         velRad = phase*lamb/(4*numpy.pi*tSamp)
                         #Spectral width
                         acf1 = ndimage.median_filter(numpy.abs(data_acf[:,1,:,:]), size = (1,5,1))
                         acf2 = ndimage.median_filter(numpy.abs(data_acf[:,2,:,:]), size = (1,5,1))
                         spcWidth = (lamb/(2*numpy.sqrt(6)*numpy.pi*tSamp))*numpy.sqrt(numpy.log(acf1/acf2))
             #             velRad = ndimage.median_filter(velRad, size = (1,5,1))
                         if allData:
                             boolMetFin = ~numpy.isnan(SNRdB)
                         else:
                             #SNR
                             boolMet1 = (SNRdB>SNRthresh) #SNR mask
                             boolMet1 = ndimage.median_filter(boolMet1, size=(1,5,5))
                             #Radial velocity
                             boolMet2 = numpy.abs(velRad) < 30
                             boolMet2 = ndimage.median_filter(boolMet2, (1,5,5))
                             #Spectral Width
                             boolMet3 = spcWidth < 30
                             boolMet3 = ndimage.median_filter(boolMet3, (1,5,5))
             #                 boolMetFin = self.__erase_small(boolMet1, 10,5)
                             boolMetFin = boolMet1&boolMet2&boolMet3
                         #Creating data_param
                         coordMet = numpy.where(boolMetFin)
                         cmet = coordMet[0]
                         tmet = coordMet[1]
                         hmet = coordMet[2]
                         data_param = numpy.zeros((tmet.size, 7))
                         data_param[:,0] = utctime
                         data_param[:,1] = cmet
                         data_param[:,2] = tmet
                         data_param[:,3] = hmet
                         data_param[:,4] = SNR[cmet,tmet,hmet].T
                         data_param[:,5] = velRad[cmet,tmet,hmet].T
                         data_param[:,6] = spcWidth[cmet,tmet,hmet].T
             #         self.dataOut.data_param = data_int
                     if len(data_param) == 0:
                         self.dataOut.flagNoData = True
                     else:
                         self.dataOut.data_param = data_param
                 def __erase_small(self, binArray, threshX, threshY):
                     labarray, numfeat = ndimage.measurements.label(binArray)
                     binArray1 = numpy.copy(binArray)
                     for i in range(1,numfeat + 1):
                         auxBin = (labarray==i)
                         auxSize = auxBin.sum()
                         x,y = numpy.where(auxBin)
                         widthX = x.max() - x.min()
                         widthY = y.max() - y.min()
                         #width X: 3 seg -> 12.5*3
                         #width Y:
                         if (auxSize < 50) or (widthX < threshX) or (widthY < threshY):
                             binArray1[auxBin] = False
                     return binArray1
             #---------------    Specular Meteor    ----------------
             class SMDetection(Operation):
                 '''
                     Function DetectMeteors()
                         Project developed with paper:
                         HOLDSWORTH ET AL. 2004
                     Input:
                         self.dataOut.data_pre
                         centerReceiverIndex:      From the channels, which is the center receiver
                         hei_ref:                  Height reference for the Beacon signal extraction
                         tauindex:
                         predefinedPhaseShifts:    Predefined phase offset for the voltge signals
                         cohDetection:             Whether to user Coherent detection or not
                         cohDet_timeStep:          Coherent Detection calculation time step
                         cohDet_thresh:            Coherent Detection phase threshold to correct phases
                         noise_timeStep:           Noise calculation time step
                         noise_multiple:           Noise multiple to define signal threshold
                         multDet_timeLimit:        Multiple Detection Removal time limit in seconds
                         multDet_rangeLimit:       Multiple Detection Removal range limit in km
                         phaseThresh:              Maximum phase difference between receiver to be consider a meteor
                         SNRThresh:                Minimum SNR threshold of the meteor signal to be consider a meteor
                         hmin:                     Minimum Height of the meteor to use it in the further wind estimations
                         hmax:                     Maximum Height of the meteor to use it in the further wind estimations
                         azimuth:                  Azimuth angle correction
                     Affected:
                         self.dataOut.data_param
                     Rejection Criteria (Errors):
 : No error; analysis OK
 : SNR < SNR threshold
 : angle of arrival (AOA) ambiguously determined
 : AOA estimate not feasible
 : Large difference in AOAs obtained from different antenna baselines
 : echo at start or end of time series
 : echo less than 5 examples long; too short for analysis
 : echo rise exceeds 0.3s
 : echo decay time less than twice rise time
 : large power level before echo
 : large power level after echo
 : poor fit to amplitude for estimation of decay time
 : poor fit to CCF phase variation for estimation of radial drift velocity
 : height unresolvable echo: not valid height within 70 to 110 km
 : height ambiguous echo: more then one possible height within 70 to 110 km
 : radial drift velocity or projected horizontal velocity exceeds 200 m/s
 : oscilatory echo, indicating event most likely not an underdense echo
 : phase difference in meteor Reestimation
                     Data Storage:
                         Meteors for Wind Estimation   (8):
                         Utc Time   |    Range    Height
                         Azimuth    Zenith    errorCosDir
                         VelRad    errorVelRad
                         Phase0 Phase1 Phase2 Phase3
                         TypeError
                      '''
                 def run(self, dataOut, hei_ref = None, tauindex = 0,
                                   phaseOffsets = None,
                                   cohDetection = False, cohDet_timeStep = 1, cohDet_thresh = 25,
                                   noise_timeStep = 4, noise_multiple = 4,
                                   multDet_timeLimit = 1, multDet_rangeLimit = 3,
                                   phaseThresh = 20, SNRThresh = 5,
                                   hmin = 50, hmax=150, azimuth = 0,
                                   channelPositions = None) :
                     #Getting Pairslist
                     if channelPositions == None:
             #             channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)]   #T
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                     meteorOps = SMOperations()
                     pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
                     heiRang = dataOut.getHeiRange()
                     #Get Beacon signal - No Beacon signal anymore
             #         newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
             #
             #         if hei_ref != None:
             #             newheis = numpy.where(self.dataOut.heightList>hei_ref)
             #
                     #****************REMOVING HARDWARE PHASE DIFFERENCES***************
                     # see if the user put in pre defined phase shifts
                     voltsPShift = dataOut.data_pre.copy()
             #         if predefinedPhaseShifts != None:
             #             hardwarePhaseShifts = numpy.array(predefinedPhaseShifts)*numpy.pi/180
             #
             # #         elif beaconPhaseShifts:
             # #             #get hardware phase shifts using beacon signal
             # #             hardwarePhaseShifts = self.__getHardwarePhaseDiff(self.dataOut.data_pre, pairslist, newheis, 10)
             # #             hardwarePhaseShifts = numpy.insert(hardwarePhaseShifts,centerReceiverIndex,0)
             #
             #         else:
             #             hardwarePhaseShifts = numpy.zeros(5)
             #
             #         voltsPShift = numpy.zeros((self.dataOut.data_pre.shape[0],self.dataOut.data_pre.shape[1],self.dataOut.data_pre.shape[2]), dtype = 'complex')
             #         for i in range(self.dataOut.data_pre.shape[0]):
             #             voltsPShift[i,:,:] = self.__shiftPhase(self.dataOut.data_pre[i,:,:], hardwarePhaseShifts[i])
                     #******************END OF REMOVING HARDWARE PHASE DIFFERENCES*********
                     #Remove DC
                     voltsDC = numpy.mean(voltsPShift,1)
                     voltsDC = numpy.mean(voltsDC,1)
                     for i in range(voltsDC.shape[0]):
                         voltsPShift[i] = voltsPShift[i] - voltsDC[i]
                     #Don't considerate last heights, theyre used to calculate Hardware Phase Shift
             #         voltsPShift = voltsPShift[:,:,:newheis[0][0]]
                     #************ FIND POWER OF DATA W/COH OR NON COH DETECTION (3.4) **********
                     #Coherent Detection
                     if cohDetection:
                         #use coherent detection to get the net power
                         cohDet_thresh = cohDet_thresh*numpy.pi/180
                         voltsPShift = self.__coherentDetection(voltsPShift, cohDet_timeStep, dataOut.timeInterval, pairslist0, cohDet_thresh)
                     #Non-coherent detection!
                     powerNet = numpy.nansum(numpy.abs(voltsPShift[:,:,:])**2,0)
                     #********** END OF COH/NON-COH POWER CALCULATION**********************
                     #********** FIND THE NOISE LEVEL AND POSSIBLE METEORS ****************
                     #Get noise
                     noise, noise1 = self.__getNoise(powerNet, noise_timeStep, dataOut.timeInterval)
             #         noise = self.getNoise1(powerNet, noise_timeStep, self.dataOut.timeInterval)
                     #Get signal threshold
                     signalThresh = noise_multiple*noise
                     #Meteor echoes detection
                     listMeteors = self.__findMeteors(powerNet, signalThresh)
                     #******* END OF NOISE LEVEL AND POSSIBLE METEORS CACULATION **********
                     #************** REMOVE MULTIPLE DETECTIONS (3.5) ***************************
                     #Parameters
                     heiRange = dataOut.getHeiRange()
                     rangeInterval = heiRange[1] - heiRange[0]
                     rangeLimit = multDet_rangeLimit/rangeInterval
                     timeLimit = multDet_timeLimit/dataOut.timeInterval
                     #Multiple detection removals
                     listMeteors1 = self.__removeMultipleDetections(listMeteors, rangeLimit, timeLimit)
                     #************ END OF REMOVE MULTIPLE DETECTIONS **********************
                     #*********************     METEOR REESTIMATION  (3.7, 3.8, 3.9, 3.10)   ********************
                     #Parameters
                     phaseThresh = phaseThresh*numpy.pi/180
                     thresh = [phaseThresh, noise_multiple, SNRThresh]
                     #Meteor reestimation  (Errors N 1, 6, 12, 17)
                     listMeteors2, listMeteorsPower, listMeteorsVolts = self.__meteorReestimation(listMeteors1, voltsPShift, pairslist0, thresh, noise, dataOut.timeInterval, dataOut.frequency)
             #         listMeteors2, listMeteorsPower, listMeteorsVolts = self.meteorReestimation3(listMeteors2, listMeteorsPower, listMeteorsVolts, voltsPShift, pairslist, thresh, noise)
                     #Estimation of decay times (Errors N 7, 8, 11)
                     listMeteors3 = self.__estimateDecayTime(listMeteors2, listMeteorsPower, dataOut.timeInterval, dataOut.frequency)
                     #*******************     END OF METEOR REESTIMATION    *******************
                     #*********************    METEOR PARAMETERS CALCULATION (3.11, 3.12, 3.13)    **************************
                     #Calculating Radial Velocity (Error N 15)
                     radialStdThresh = 10
                     listMeteors4 = self.__getRadialVelocity(listMeteors3, listMeteorsVolts, radialStdThresh, pairslist0, dataOut.timeInterval)
                     if len(listMeteors4) > 0:
                         #Setting New Array
                         date = dataOut.utctime
                         arrayParameters = self.__setNewArrays(listMeteors4, date, heiRang)
                         #Correcting phase offset
                         if phaseOffsets != None:
                             phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
                             arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
                         #Second Pairslist
                         pairsList = []
                         pairx = (0,1)
                         pairy = (2,3)
                         pairsList.append(pairx)
                         pairsList.append(pairy)
                         jph = numpy.array([0,0,0,0])
                         h = (hmin,hmax)
                         arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
             #             #Calculate AOA (Error N 3, 4)
             #             #JONES ET AL. 1998
             #             error = arrayParameters[:,-1]
             #             AOAthresh = numpy.pi/8
             #             phases = -arrayParameters[:,9:13]
             #             arrayParameters[:,4:7], arrayParameters[:,-1] = meteorOps.getAOA(phases, pairsList, error, AOAthresh, azimuth)
             #
             #             #Calculate Heights (Error N 13 and 14)
             #             error = arrayParameters[:,-1]
             #             Ranges = arrayParameters[:,2]
             #             zenith = arrayParameters[:,5]
             #             arrayParameters[:,3], arrayParameters[:,-1] = meteorOps.getHeights(Ranges, zenith, error, hmin, hmax)
             #             error = arrayParameters[:,-1]
                     #*********************    END OF PARAMETERS CALCULATION    **************************
                     #***************************+     PASS DATA TO NEXT STEP    **********************
             #             arrayFinal = arrayParameters.reshape((1,arrayParameters.shape[0],arrayParameters.shape[1]))
                         dataOut.data_param = arrayParameters
                         if arrayParameters == None:
                             dataOut.flagNoData = True
                     else:
                         dataOut.flagNoData = True
                     return
                 def __getHardwarePhaseDiff(self, voltage0, pairslist, newheis, n):
                     minIndex = min(newheis[0])
                     maxIndex = max(newheis[0])
                     voltage = voltage0[:,:,minIndex:maxIndex+1]
                     nLength = voltage.shape[1]/n
                     nMin = 0
                     nMax = 0
                     phaseOffset = numpy.zeros((len(pairslist),n))
                     for i in range(n):
                         nMax += nLength
                         phaseCCF = -numpy.angle(self.__calculateCCF(voltage[:,nMin:nMax,:], pairslist, [0]))
                         phaseCCF = numpy.mean(phaseCCF, axis = 2)
                         phaseOffset[:,i] = phaseCCF.transpose()
                         nMin = nMax
             #         phaseDiff, phaseArrival = self.estimatePhaseDifference(voltage, pairslist)
                     #Remove Outliers
                     factor = 2
                     wt = phaseOffset - signal.medfilt(phaseOffset,(1,5))
                     dw = numpy.std(wt,axis = 1)
                     dw = dw.reshape((dw.size,1))
                     ind = numpy.where(numpy.logical_or(wt>dw*factor,wt<-dw*factor))
                     phaseOffset[ind] = numpy.nan
                     phaseOffset = stats.nanmean(phaseOffset, axis=1)
                     return phaseOffset
                 def __shiftPhase(self, data, phaseShift):
                     #this will shift the phase of a complex number
                     dataShifted = numpy.abs(data) * numpy.exp((numpy.angle(data)+phaseShift)*1j)
                     return dataShifted
                 def __estimatePhaseDifference(self, array, pairslist):
                     nChannel = array.shape[0]
                     nHeights = array.shape[2]
                     numPairs = len(pairslist)
             #         phaseCCF = numpy.zeros((nChannel, 5, nHeights))
                     phaseCCF = numpy.angle(self.__calculateCCF(array, pairslist, [-2,-1,0,1,2]))
                     #Correct phases
                     derPhaseCCF = phaseCCF[:,1:,:] - phaseCCF[:,0:-1,:]
                     indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
                     if indDer[0].shape[0] > 0:
                         for i in range(indDer[0].shape[0]):
                             signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i],indDer[2][i]])
                             phaseCCF[indDer[0][i],indDer[1][i]+1:,:] += signo*2*numpy.pi
             #         for j in range(numSides):
             #             phaseCCFAux = self.calculateCCF(arrayCenter, arraySides[j,:,:], [-2,1,0,1,2])
             #             phaseCCF[j,:,:] = numpy.angle(phaseCCFAux)
             #
                     #Linear
                     phaseInt = numpy.zeros((numPairs,1))
                     angAllCCF = phaseCCF[:,[0,1,3,4],0]
                     for j in range(numPairs):
                         fit = stats.linregress([-2,-1,1,2],angAllCCF[j,:])
                         phaseInt[j] = fit[1]
                     #Phase Differences
                     phaseDiff = phaseInt - phaseCCF[:,2,:]
                     phaseArrival = phaseInt.reshape(phaseInt.size)
                     #Dealias
                     phaseArrival = numpy.angle(numpy.exp(1j*phaseArrival))
             #         indAlias = numpy.where(phaseArrival > numpy.pi)
             #         phaseArrival[indAlias] -= 2*numpy.pi
             #         indAlias = numpy.where(phaseArrival < -numpy.pi)
             #         phaseArrival[indAlias] += 2*numpy.pi
                     return phaseDiff, phaseArrival
                 def __coherentDetection(self, volts, timeSegment, timeInterval, pairslist, thresh):
                     #this function will run the coherent detection used in Holdworth et al. 2004 and return the net power
                     #find the phase shifts of each channel over 1 second intervals
                     #only look at ranges below the beacon signal
                     numProfPerBlock = numpy.ceil(timeSegment/timeInterval)
                     numBlocks = int(volts.shape[1]/numProfPerBlock)
                     numHeights = volts.shape[2]
                     nChannel = volts.shape[0]
                     voltsCohDet = volts.copy()
                     pairsarray = numpy.array(pairslist)
                     indSides = pairsarray[:,1]
             #         indSides = numpy.array(range(nChannel))
             #         indSides = numpy.delete(indSides, indCenter)
             #
             #         listCenter = numpy.array_split(volts[indCenter,:,:], numBlocks, 0)
                     listBlocks = numpy.array_split(volts, numBlocks, 1)
                     startInd = 0
                     endInd = 0
                     for i in range(numBlocks):
                         startInd = endInd
                         endInd = endInd + listBlocks[i].shape[1]
                         arrayBlock = listBlocks[i]
             #             arrayBlockCenter = listCenter[i]
                         #Estimate the Phase Difference
                         phaseDiff, aux = self.__estimatePhaseDifference(arrayBlock, pairslist)
                         #Phase Difference RMS
                         arrayPhaseRMS = numpy.abs(phaseDiff)
                         phaseRMSaux = numpy.sum(arrayPhaseRMS < thresh,0)
                         indPhase = numpy.where(phaseRMSaux==4)
                         #Shifting
                         if indPhase[0].shape[0] > 0:
                             for j in range(indSides.size):
                                 arrayBlock[indSides[j],:,indPhase] = self.__shiftPhase(arrayBlock[indSides[j],:,indPhase], phaseDiff[j,indPhase].transpose())
                             voltsCohDet[:,startInd:endInd,:] = arrayBlock
                     return voltsCohDet
                 def __calculateCCF(self, volts, pairslist ,laglist):
                     nHeights = volts.shape[2]
                     nPoints = volts.shape[1]
                     voltsCCF = numpy.zeros((len(pairslist), len(laglist), nHeights),dtype = 'complex')
                     for i in range(len(pairslist)):
                         volts1 = volts[pairslist[i][0]]
                         volts2 = volts[pairslist[i][1]]
                         for t in range(len(laglist)):
                             idxT = laglist[t]
                             if idxT >= 0:
                                 vStacked = numpy.vstack((volts2[idxT:,:],
                                                        numpy.zeros((idxT, nHeights),dtype='complex')))
                             else:
                                 vStacked = numpy.vstack((numpy.zeros((-idxT, nHeights),dtype='complex'),
                                                        volts2[:(nPoints + idxT),:]))
                             voltsCCF[i,t,:] = numpy.sum((numpy.conjugate(volts1)*vStacked),axis=0)
                             vStacked = None
                     return voltsCCF
                 def __getNoise(self, power, timeSegment, timeInterval):
                     numProfPerBlock = numpy.ceil(timeSegment/timeInterval)
                     numBlocks = int(power.shape[0]/numProfPerBlock)
                     numHeights = power.shape[1]
                     listPower = numpy.array_split(power, numBlocks, 0)
                     noise = numpy.zeros((power.shape[0], power.shape[1]))
                     noise1 = numpy.zeros((power.shape[0], power.shape[1]))
                     startInd = 0
                     endInd = 0
                     for i in range(numBlocks):             #split por canal
                         startInd = endInd
                         endInd = endInd + listPower[i].shape[0]
                         arrayBlock = listPower[i]
                         noiseAux = numpy.mean(arrayBlock, 0)
             #             noiseAux = numpy.median(noiseAux)
             #             noiseAux = numpy.mean(arrayBlock)
                         noise[startInd:endInd,:] = noise[startInd:endInd,:] + noiseAux
                         noiseAux1 = numpy.mean(arrayBlock)
                         noise1[startInd:endInd,:] = noise1[startInd:endInd,:] + noiseAux1
                     return noise, noise1
                 def __findMeteors(self, power, thresh):
                     nProf = power.shape[0]
                     nHeights = power.shape[1]
                     listMeteors = []
                     for i in range(nHeights):
                         powerAux = power[:,i]
                         threshAux = thresh[:,i]
                         indUPthresh = numpy.where(powerAux > threshAux)[0]
                         indDNthresh = numpy.where(powerAux <= threshAux)[0]
                         j = 0
                         while (j < indUPthresh.size - 2):
                             if (indUPthresh[j + 2] == indUPthresh[j] + 2):
                                 indDNAux = numpy.where(indDNthresh > indUPthresh[j])
                                 indDNthresh = indDNthresh[indDNAux]
                                 if (indDNthresh.size > 0):
                                     indEnd = indDNthresh[0] - 1
                                     indInit = indUPthresh[j]
                                     meteor = powerAux[indInit:indEnd + 1]
                                     indPeak = meteor.argmax() + indInit
                                     FLA = sum(numpy.conj(meteor)*numpy.hstack((meteor[1:],0)))
                                     listMeteors.append(numpy.array([i,indInit,indPeak,indEnd,FLA])) #CHEQUEAR!!!!!
                                     j = numpy.where(indUPthresh == indEnd)[0] + 1
                                 else: j+=1
                             else: j+=1
                     return listMeteors
                 def __removeMultipleDetections(self,listMeteors, rangeLimit, timeLimit):
                     arrayMeteors = numpy.asarray(listMeteors)
                     listMeteors1 = []
                     while arrayMeteors.shape[0] > 0:
                         FLAs = arrayMeteors[:,4]
                         maxFLA = FLAs.argmax()
                         listMeteors1.append(arrayMeteors[maxFLA,:])
                         MeteorInitTime = arrayMeteors[maxFLA,1]
                         MeteorEndTime = arrayMeteors[maxFLA,3]
                         MeteorHeight = arrayMeteors[maxFLA,0]
                         #Check neighborhood
                         maxHeightIndex = MeteorHeight + rangeLimit
                         minHeightIndex = MeteorHeight - rangeLimit
                         minTimeIndex = MeteorInitTime - timeLimit
                         maxTimeIndex = MeteorEndTime + timeLimit
                         #Check Heights
                         indHeight = numpy.logical_and(arrayMeteors[:,0] >= minHeightIndex, arrayMeteors[:,0] <= maxHeightIndex)
                         indTime = numpy.logical_and(arrayMeteors[:,3] >= minTimeIndex, arrayMeteors[:,1] <= maxTimeIndex)
                         indBoth = numpy.where(numpy.logical_and(indTime,indHeight))
                         arrayMeteors = numpy.delete(arrayMeteors, indBoth, axis = 0)
                     return listMeteors1
                 def __meteorReestimation(self, listMeteors, volts, pairslist, thresh, noise, timeInterval,frequency):
                     numHeights = volts.shape[2]
                     nChannel = volts.shape[0]
                     thresholdPhase = thresh[0]
                     thresholdNoise = thresh[1]
                     thresholdDB = float(thresh[2])
                     thresholdDB1 = 10**(thresholdDB/10)
                     pairsarray = numpy.array(pairslist)
                     indSides = pairsarray[:,1]
                     pairslist1 = list(pairslist)
                     pairslist1.append((0,1))
                     pairslist1.append((3,4))
                     listMeteors1 = []
                     listPowerSeries = []
                     listVoltageSeries = []
                     #volts has the war data
                     if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
                     lag = numpy.ceil(timeLag/timeInterval)
                     for i in range(len(listMeteors)):
                         ######################   3.6 - 3.7 PARAMETERS REESTIMATION    #########################
                         meteorAux = numpy.zeros(16)
                         #Loading meteor Data (mHeight, mStart, mPeak, mEnd)
                         mHeight = listMeteors[i][0]
                         mStart = listMeteors[i][1]
                         mPeak = listMeteors[i][2]
                         mEnd = listMeteors[i][3]
                         #get the volt data between the start and end times of the meteor
                         meteorVolts = volts[:,mStart:mEnd+1,mHeight]
                         meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
                         #3.6. Phase Difference estimation
                         phaseDiff, aux = self.__estimatePhaseDifference(meteorVolts, pairslist)
                         #3.7. Phase difference removal & meteor start, peak and end times reestimated
                         #meteorVolts0.- all Channels, all Profiles
                         meteorVolts0 = volts[:,:,mHeight]
                         meteorThresh = noise[:,mHeight]*thresholdNoise
                         meteorNoise = noise[:,mHeight]
                         meteorVolts0[indSides,:] = self.__shiftPhase(meteorVolts0[indSides,:], phaseDiff) #Phase Shifting
                         powerNet0 = numpy.nansum(numpy.abs(meteorVolts0)**2, axis = 0)  #Power
                         #Times reestimation
                         mStart1 = numpy.where(powerNet0[:mPeak] < meteorThresh[:mPeak])[0]
                         if mStart1.size > 0:
                             mStart1 = mStart1[-1] + 1
                         else:
                             mStart1 = mPeak
                         mEnd1 = numpy.where(powerNet0[mPeak:] < meteorThresh[mPeak:])[0][0] + mPeak - 1
                         mEndDecayTime1 = numpy.where(powerNet0[mPeak:] < meteorNoise[mPeak:])[0]
                         if mEndDecayTime1.size == 0:
                             mEndDecayTime1 = powerNet0.size
                         else:
                             mEndDecayTime1 = mEndDecayTime1[0] + mPeak - 1
             #             mPeak1 = meteorVolts0[mStart1:mEnd1 + 1].argmax()
                         #meteorVolts1.- all Channels, from start to end
                         meteorVolts1 = meteorVolts0[:,mStart1:mEnd1 + 1]
                         meteorVolts2 = meteorVolts0[:,mPeak + lag:mEnd1 + 1]
                         if meteorVolts2.shape[1] == 0:
                             meteorVolts2 = meteorVolts0[:,mPeak:mEnd1 + 1]
                         meteorVolts1 = meteorVolts1.reshape(meteorVolts1.shape[0], meteorVolts1.shape[1], 1)
                         meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1], 1)
                         #####################    END PARAMETERS REESTIMATION    #########################
                         #####################   3.8 PHASE DIFFERENCE REESTIMATION  ########################
             #             if mEnd1 - mStart1 > 4:       #Error Number 6: echo less than 5 samples long; too short for analysis
                         if meteorVolts2.shape[1] > 0:
                             #Phase Difference re-estimation
                             phaseDiff1, phaseDiffint = self.__estimatePhaseDifference(meteorVolts2, pairslist1)   #Phase Difference Estimation
             #                 phaseDiff1, phaseDiffint = self.estimatePhaseDifference(meteorVolts2, pairslist)
                             meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1])
                             phaseDiff11 = numpy.reshape(phaseDiff1, (phaseDiff1.shape[0],1))
                             meteorVolts2[indSides,:] = self.__shiftPhase(meteorVolts2[indSides,:], phaseDiff11[0:4])     #Phase Shifting
                             #Phase Difference RMS
                             phaseRMS1 = numpy.sqrt(numpy.mean(numpy.square(phaseDiff1)))
                             powerNet1 = numpy.nansum(numpy.abs(meteorVolts1[:,:])**2,0)
                             #Data from Meteor
                             mPeak1 = powerNet1.argmax() + mStart1
                             mPeakPower1 = powerNet1.max()
                             noiseAux = sum(noise[mStart1:mEnd1 + 1,mHeight])
                             mSNR1 = (sum(powerNet1)-noiseAux)/noiseAux
                             Meteor1 = numpy.array([mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1])
                             Meteor1 = numpy.hstack((Meteor1,phaseDiffint))
                             PowerSeries  = powerNet0[mStart1:mEndDecayTime1 + 1]
                             #Vectorize
                             meteorAux[0:7] = [mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1]
                             meteorAux[7:11] = phaseDiffint[0:4]
                             #Rejection Criterions
                             if phaseRMS1 > thresholdPhase:  #Error Number 17: Phase variation
                                 meteorAux[-1] = 17
                             elif mSNR1 < thresholdDB1:      #Error Number 1: SNR < threshold dB
                                 meteorAux[-1] = 1
                         else:
                             meteorAux[0:4] = [mHeight, mStart, mPeak, mEnd]
                             meteorAux[-1] = 6 #Error Number 6: echo less than 5 samples long; too short for analysis
                             PowerSeries = 0
                         listMeteors1.append(meteorAux)
                         listPowerSeries.append(PowerSeries)
                         listVoltageSeries.append(meteorVolts1)
                     return listMeteors1, listPowerSeries, listVoltageSeries
                 def __estimateDecayTime(self, listMeteors, listPower, timeInterval, frequency):
                     threshError = 10
                     #Depending if it is 30 or 50 MHz
                     if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
                     lag = numpy.ceil(timeLag/timeInterval)
                     listMeteors1 = []
                     for i in range(len(listMeteors)):
                         meteorPower = listPower[i]
                         meteorAux = listMeteors[i]
                         if meteorAux[-1] == 0:
                             try:
                                 indmax = meteorPower.argmax()
                                 indlag = indmax + lag
                                 y = meteorPower[indlag:]
                                 x = numpy.arange(0, y.size)*timeLag
                                 #first guess
                                 a = y[0]
                                 tau = timeLag
                                 #exponential fit
                                 popt, pcov = optimize.curve_fit(self.__exponential_function, x, y, p0 = [a, tau])
                                 y1 = self.__exponential_function(x, *popt)
                                 #error estimation
                                 error = sum((y - y1)**2)/(numpy.var(y)*(y.size - popt.size))
                                 decayTime = popt[1]
                                 riseTime = indmax*timeInterval
                                 meteorAux[11:13] = [decayTime, error]
                                 #Table items 7, 8 and 11
                                 if (riseTime > 0.3):            #Number 7: Echo rise exceeds 0.3s
                                     meteorAux[-1] = 7
                                 elif (decayTime < 2*riseTime) : #Number 8: Echo decay time less than than twice rise time
                                     meteorAux[-1] = 8
                                 if (error > threshError):       #Number 11: Poor fit to amplitude for estimation of decay time
                                     meteorAux[-1] = 11
                             except:
                                 meteorAux[-1] = 11
                         listMeteors1.append(meteorAux)
                     return listMeteors1
                 #Exponential Function
                 def __exponential_function(self, x, a, tau):
                     y = a*numpy.exp(-x/tau)
                     return y
                 def __getRadialVelocity(self, listMeteors, listVolts, radialStdThresh, pairslist,  timeInterval):
                     pairslist1 = list(pairslist)
                     pairslist1.append((0,1))
                     pairslist1.append((3,4))
                     numPairs = len(pairslist1)
                     #Time Lag
                     timeLag = 45*10**-3
                     c = 3e8
                     lag = numpy.ceil(timeLag/timeInterval)
                     freq = 30e6
                     listMeteors1 = []
                     for i in range(len(listMeteors)):
                         meteorAux = listMeteors[i]
                         if meteorAux[-1] == 0:
                             mStart = listMeteors[i][1]
                             mPeak = listMeteors[i][2]
                             mLag = mPeak - mStart + lag
                             #get the volt data between the start and end times of the meteor
                             meteorVolts = listVolts[i]
                             meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
                             #Get CCF
                             allCCFs = self.__calculateCCF(meteorVolts, pairslist1, [-2,-1,0,1,2])
                             #Method 2
                             slopes = numpy.zeros(numPairs)
                             time = numpy.array([-2,-1,1,2])*timeInterval
                             angAllCCF = numpy.angle(allCCFs[:,[0,1,3,4],0])
                             #Correct phases
                             derPhaseCCF = angAllCCF[:,1:] - angAllCCF[:,0:-1]
                             indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
                             if indDer[0].shape[0] > 0:
                                 for i in range(indDer[0].shape[0]):
                                     signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i]])
                                     angAllCCF[indDer[0][i],indDer[1][i]+1:] += signo*2*numpy.pi
             #                     fit = scipy.stats.linregress(numpy.array([-2,-1,1,2])*timeInterval, numpy.array([phaseLagN2s[i],phaseLagN1s[i],phaseLag1s[i],phaseLag2s[i]]))
                             for j in range(numPairs):
                                 fit = stats.linregress(time, angAllCCF[j,:])
                                 slopes[j] = fit[0]
                             #Remove Outlier
             #                 indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
             #                 slopes = numpy.delete(slopes,indOut)
             #                 indOut = numpy.argmax(numpy.abs(slopes - numpy.mean(slopes)))
             #                 slopes = numpy.delete(slopes,indOut)
                             radialVelocity = -numpy.mean(slopes)*(0.25/numpy.pi)*(c/freq)
                             radialError = numpy.std(slopes)*(0.25/numpy.pi)*(c/freq)
                             meteorAux[-2] = radialError
                             meteorAux[-3] = radialVelocity
                             #Setting Error
                             #Number 15: Radial Drift velocity or projected horizontal velocity exceeds 200 m/s
                             if numpy.abs(radialVelocity) > 200:
                                 meteorAux[-1] = 15
                             #Number 12: Poor fit to CCF variation for estimation of radial drift velocity
                             elif radialError > radialStdThresh:
                                 meteorAux[-1] = 12
                         listMeteors1.append(meteorAux)
                     return listMeteors1
                 def __setNewArrays(self, listMeteors, date, heiRang):
                     #New arrays
                     arrayMeteors = numpy.array(listMeteors)
                     arrayParameters = numpy.zeros((len(listMeteors), 13))
                     #Date inclusion
             #         date = re.findall(r'\((.*?)\)', date)
             #         date = date[0].split(',')
             #         date = map(int, date)
             #
             #         if len(date)<6:
             #             date.append(0)
             #
             #         date = [date[0]*10000 + date[1]*100 + date[2], date[3]*10000 + date[4]*100 + date[5]]
             #         arrayDate = numpy.tile(date, (len(listMeteors), 1))
                     arrayDate = numpy.tile(date, (len(listMeteors)))
                     #Meteor array
             #         arrayMeteors[:,0] = heiRang[arrayMeteors[:,0].astype(int)]
             #         arrayMeteors = numpy.hstack((arrayDate, arrayMeteors))
                     #Parameters Array
                     arrayParameters[:,0] = arrayDate #Date
                     arrayParameters[:,1] = heiRang[arrayMeteors[:,0].astype(int)] #Range
                     arrayParameters[:,6:8] = arrayMeteors[:,-3:-1] #Radial velocity and its error
                     arrayParameters[:,8:12] = arrayMeteors[:,7:11]  #Phases
                     arrayParameters[:,-1] = arrayMeteors[:,-1]  #Error
                     return arrayParameters
             class CorrectSMPhases(Operation):
                 def run(self, dataOut, phaseOffsets, hmin = 50, hmax = 150, azimuth = 45, channelPositions = None):
                     arrayParameters = dataOut.data_param
                     pairsList = []
                     pairx = (0,1)
                     pairy = (2,3)
                     pairsList.append(pairx)
                     pairsList.append(pairy)
                     jph = numpy.zeros(4)
                     phaseOffsets = numpy.array(phaseOffsets)*numpy.pi/180
                 #         arrayParameters[:,8:12] = numpy.unwrap(arrayParameters[:,8:12] + phaseOffsets)
                     arrayParameters[:,8:12] = numpy.angle(numpy.exp(1j*(arrayParameters[:,8:12] + phaseOffsets)))
                     meteorOps = SMOperations()
                     if channelPositions == None:
                 #             channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)]   #T
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                     pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
                     h = (hmin,hmax)
                     arrayParameters = meteorOps.getMeteorParams(arrayParameters, azimuth, h, pairsList, distances, jph)
                     dataOut.data_param = arrayParameters
                     return
             class SMPhaseCalibration(Operation):
                 __buffer = None
                 __initime = None
                 __dataReady = False
                 __isConfig = False
                 def __checkTime(self, currentTime, initTime, paramInterval, outputInterval):
                     dataTime = currentTime + paramInterval
                     deltaTime = dataTime - initTime
                     if deltaTime >= outputInterval or deltaTime < 0:
                         return True
                     return False
                 def __getGammas(self, pairs, d, phases):
                     gammas = numpy.zeros(2)
                     for i in range(len(pairs)):
                         pairi = pairs[i]
                         phip3 = phases[:,pairi[1]]
                         d3 = d[pairi[1]]
                         phip2 = phases[:,pairi[0]]
                         d2 = d[pairi[0]]
                         #Calculating gamma
             #             jdcos = alp1/(k*d1)
             #             jgamma = numpy.angle(numpy.exp(1j*(d0*alp1/d1 - alp0)))
                         jgamma = -phip2*d3/d2 - phip3
                         jgamma = numpy.angle(numpy.exp(1j*jgamma))
             #             jgamma[jgamma>numpy.pi] -= 2*numpy.pi
             #             jgamma[jgamma<-numpy.pi] += 2*numpy.pi
                         #Revised distribution
                         jgammaArray = numpy.hstack((jgamma,jgamma+0.5*numpy.pi,jgamma-0.5*numpy.pi))
                         #Histogram
                         nBins = 64.0
                         rmin = -0.5*numpy.pi
                         rmax = 0.5*numpy.pi
                         phaseHisto = numpy.histogram(jgammaArray, bins=nBins, range=(rmin,rmax))
                         meteorsY = phaseHisto[0]
                         phasesX = phaseHisto[1][:-1]
                         width = phasesX[1] - phasesX[0]
                         phasesX += width/2
                         #Gaussian aproximation
                         bpeak = meteorsY.argmax()
                         peak = meteorsY.max()
                         jmin = bpeak - 5
                         jmax = bpeak + 5 + 1
                         if jmin<0:
                             jmin = 0
                             jmax = 6
                         elif jmax > meteorsY.size:
                             jmin = meteorsY.size - 6
                             jmax = meteorsY.size
                         x0 = numpy.array([peak,bpeak,50])
                         coeff = optimize.leastsq(self.__residualFunction, x0, args=(meteorsY[jmin:jmax], phasesX[jmin:jmax]))
                         #Gammas
                         gammas[i] = coeff[0][1]
                     return gammas
                 def __residualFunction(self, coeffs, y, t):
                     return y - self.__gauss_function(t, coeffs)
                 def __gauss_function(self, t, coeffs):
                     return coeffs[0]*numpy.exp(-0.5*((t - coeffs[1]) / coeffs[2])**2)
                 def __getPhases(self, azimuth, h, pairsList, d, gammas, meteorsArray):
                     meteorOps = SMOperations()
                     nchan = 4
                     pairx = pairsList[0]
                     pairy = pairsList[1]
                     center_xangle = 0
                     center_yangle = 0
                     range_angle = numpy.array([10*numpy.pi,numpy.pi,numpy.pi/2,numpy.pi/4])
                     ntimes = len(range_angle)
                     nstepsx = 20.0
                     nstepsy = 20.0
                     for iz in range(ntimes):
                         min_xangle = -range_angle[iz]/2 + center_xangle
                         max_xangle = range_angle[iz]/2 + center_xangle
                         min_yangle = -range_angle[iz]/2 + center_yangle
                         max_yangle = range_angle[iz]/2 + center_yangle
                         inc_x = (max_xangle-min_xangle)/nstepsx
                         inc_y = (max_yangle-min_yangle)/nstepsy
                         alpha_y = numpy.arange(nstepsy)*inc_y + min_yangle
                         alpha_x = numpy.arange(nstepsx)*inc_x + min_xangle
                         penalty = numpy.zeros((nstepsx,nstepsy))
                         jph_array = numpy.zeros((nchan,nstepsx,nstepsy))
                         jph = numpy.zeros(nchan)
                         # Iterations looking for the offset
                         for iy in range(int(nstepsy)):
                             for ix in range(int(nstepsx)):
                                 jph[pairy[1]] = alpha_y[iy]
                                 jph[pairy[0]] = -gammas[1] - alpha_y[iy]*d[pairy[1]]/d[pairy[0]]
                                 jph[pairx[1]] = alpha_x[ix]
                                 jph[pairx[0]] = -gammas[0] - alpha_x[ix]*d[pairx[1]]/d[pairx[0]]
                                 jph_array[:,ix,iy] = jph
                                 meteorsArray1 = meteorOps.getMeteorParams(meteorsArray, azimuth, h, pairsList, d, jph)
                                 error = meteorsArray1[:,-1]
                                 ind1 = numpy.where(error==0)[0]
                                 penalty[ix,iy] = ind1.size
                         i,j = numpy.unravel_index(penalty.argmax(), penalty.shape)
                         phOffset = jph_array[:,i,j]
                         center_xangle = phOffset[pairx[1]]
                         center_yangle = phOffset[pairy[1]]
                     phOffset = numpy.angle(numpy.exp(1j*jph_array[:,i,j]))
                     phOffset = phOffset*180/numpy.pi
                     return phOffset
                 def run(self, dataOut, hmin, hmax, channelPositions=None, nHours = 1):
                     dataOut.flagNoData = True
                     self.__dataReady = False
                     dataOut.outputInterval = nHours*3600
                     if self.__isConfig == False:
             #                 self.__initime = dataOut.datatime.replace(minute = 0, second = 0, microsecond = 03)
                         #Get Initial LTC time
                         self.__initime = datetime.datetime.utcfromtimestamp(dataOut.utctime)
                         self.__initime = (self.__initime.replace(minute = 0, second = 0, microsecond = 0) - datetime.datetime(1970, 1, 1)).total_seconds()
                         self.__isConfig = True
                     if self.__buffer == None:
                         self.__buffer = dataOut.data_param.copy()
                     else:
                         self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
                     self.__dataReady = self.__checkTime(dataOut.utctime, self.__initime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
                     if self.__dataReady:
                         dataOut.utctimeInit = self.__initime
                         self.__initime += dataOut.outputInterval #to erase time offset
                         freq = dataOut.frequency
                         c = dataOut.C #m/s
                         lamb = c/freq
                         k = 2*numpy.pi/lamb
                         azimuth = 0
                         h = (hmin, hmax)
                         pairs = ((0,1),(2,3))
                         if channelPositions == None:
             #             channelPositions = [(2.5,0), (0,2.5), (0,0), (0,4.5), (-2,0)]   #T
                             channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                         meteorOps = SMOperations()
                         pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
             #             distances1 = [-distances[0]*lamb, distances[1]*lamb, -distances[2]*lamb, distances[3]*lamb]
                         meteorsArray = self.__buffer
                         error = meteorsArray[:,-1]
                         boolError = (error==0)|(error==3)|(error==4)|(error==13)|(error==14)
                         ind1 = numpy.where(boolError)[0]
                         meteorsArray = meteorsArray[ind1,:]
                         meteorsArray[:,-1] = 0
                         phases = meteorsArray[:,8:12]
                         #Calculate Gammas
                         gammas = self.__getGammas(pairs, distances, phases)
             #             gammas = numpy.array([-21.70409463,45.76935864])*numpy.pi/180
                         #Calculate Phases
                         phasesOff = self.__getPhases(azimuth, h, pairs, distances, gammas, meteorsArray)
                         phasesOff = phasesOff.reshape((1,phasesOff.size))
                         dataOut.data_output = -phasesOff
                         dataOut.flagNoData = False
                         self.__buffer = None
                     return
             class SMOperations():
                 def __init__(self):
                     return
                 def getMeteorParams(self, arrayParameters0, azimuth, h, pairsList, distances, jph):
                     arrayParameters = arrayParameters0.copy()
                     hmin = h[0]
                     hmax = h[1]
                     #Calculate AOA (Error N 3, 4)
                     #JONES ET AL. 1998
                     AOAthresh = numpy.pi/8
                     error = arrayParameters[:,-1]
                     phases = -arrayParameters[:,8:12] + jph
             #         phases = numpy.unwrap(phases)
                     arrayParameters[:,3:6], arrayParameters[:,-1] = self.__getAOA(phases, pairsList, distances, error, AOAthresh, azimuth)
                     #Calculate Heights (Error N 13 and 14)
                     error = arrayParameters[:,-1]
                     Ranges = arrayParameters[:,1]
                     zenith = arrayParameters[:,4]
                     arrayParameters[:,2], arrayParameters[:,-1] = self.__getHeights(Ranges, zenith, error, hmin, hmax)
                     #----------------------- Get Final data    ------------------------------------
             #         error = arrayParameters[:,-1]
             #         ind1 = numpy.where(error==0)[0]
             #         arrayParameters = arrayParameters[ind1,:]
                     return arrayParameters
                 def __getAOA(self, phases, pairsList, directions, error, AOAthresh, azimuth):
                     arrayAOA = numpy.zeros((phases.shape[0],3))
                     cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList,directions)
                     arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
                     cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
                     arrayAOA[:,2] = cosDirError
                     azimuthAngle = arrayAOA[:,0]
                     zenithAngle = arrayAOA[:,1]
                     #Setting Error
                     indError = numpy.where(numpy.logical_or(error == 3, error == 4))[0]
                     error[indError] = 0
                     #Number 3: AOA not fesible
                     indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
                     error[indInvalid] = 3
                     #Number 4: Large difference in AOAs obtained from different antenna baselines
                     indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
                     error[indInvalid] = 4
                     return arrayAOA, error
                 def __getDirectionCosines(self, arrayPhase, pairsList, distances):
                     #Initializing some variables
                     ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
                     ang_aux = ang_aux.reshape(1,ang_aux.size)
                     cosdir = numpy.zeros((arrayPhase.shape[0],2))
                     cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
                     for i in range(2):
                         ph0 = arrayPhase[:,pairsList[i][0]]
                         ph1 = arrayPhase[:,pairsList[i][1]]
                         d0 = distances[pairsList[i][0]]
                         d1 = distances[pairsList[i][1]]
                         ph0_aux = ph0 + ph1
                         ph0_aux = numpy.angle(numpy.exp(1j*ph0_aux))
             #             ph0_aux[ph0_aux > numpy.pi] -= 2*numpy.pi
             #             ph0_aux[ph0_aux < -numpy.pi] += 2*numpy.pi
                         #First Estimation
                         cosdir0[:,i] = (ph0_aux)/(2*numpy.pi*(d0 - d1))
                         #Most-Accurate Second Estimation
                         phi1_aux =  ph0 - ph1
                         phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
                         #Direction Cosine 1
                         cosdir1 = (phi1_aux + ang_aux)/(2*numpy.pi*(d0 + d1))
                         #Searching the correct Direction Cosine
                         cosdir0_aux = cosdir0[:,i]
                         cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
                         #Minimum Distance
                         cosDiff = (cosdir1 - cosdir0_aux)**2
                         indcos = cosDiff.argmin(axis = 1)
                         #Saving Value obtained
                         cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
                     return cosdir0, cosdir
                 def __calculateAOA(self, cosdir, azimuth):
                     cosdirX = cosdir[:,0]
                     cosdirY = cosdir[:,1]
                     zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
                     azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth#0 deg north, 90 deg east
                     angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
                     return angles
                 def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
                     Ramb = 375  #Ramb = c/(2*PRF)
                     Re = 6371   #Earth Radius
                     heights = numpy.zeros(Ranges.shape)
                     R_aux = numpy.array([0,1,2])*Ramb
                     R_aux = R_aux.reshape(1,R_aux.size)
                     Ranges = Ranges.reshape(Ranges.size,1)
                     Ri = Ranges + R_aux
                     hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
                     #Check if there is a height between 70 and 110 km
                     h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
                     ind_h = numpy.where(h_bool == 1)[0]
                     hCorr = hi[ind_h, :]
                     ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
                     hCorr = hi[ind_hCorr]
                     heights[ind_h] = hCorr
                     #Setting Error
                     #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
                     #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
                     indError = numpy.where(numpy.logical_or(error == 13, error == 14))[0]
                     error[indError] = 0
                     indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
                     error[indInvalid2] = 14
                     indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
                     error[indInvalid1] = 13
                     return heights, error
                 def getPhasePairs(self, channelPositions):
                     chanPos = numpy.array(channelPositions)
                     listOper = list(itertools.combinations(range(5),2))
                     distances = numpy.zeros(4)
                     axisX = []
                     axisY = []
                     distX = numpy.zeros(3)
                     distY = numpy.zeros(3)
                     ix = 0
                     iy = 0
                     pairX = numpy.zeros((2,2))
                     pairY = numpy.zeros((2,2))
                     for i in range(len(listOper)):
                         pairi = listOper[i]
                         posDif = numpy.abs(chanPos[pairi[0],:] - chanPos[pairi[1],:])
                         if posDif[0] == 0:
                             axisY.append(pairi)
                             distY[iy] = posDif[1]
                             iy += 1
                         elif posDif[1] == 0:
                             axisX.append(pairi)
                             distX[ix] = posDif[0]
                             ix += 1
                     for i in range(2):
                         if i==0:
                             dist0 = distX
                             axis0 = axisX
                         else:
                             dist0 = distY
                             axis0 = axisY
                         side = numpy.argsort(dist0)[:-1]
                         axis0 = numpy.array(axis0)[side,:]
                         chanC = int(numpy.intersect1d(axis0[0,:], axis0[1,:])[0])
                         axis1 = numpy.unique(numpy.reshape(axis0,4))
                         side = axis1[axis1 != chanC]
                         diff1 = chanPos[chanC,i] - chanPos[side[0],i]
                         diff2 = chanPos[chanC,i] - chanPos[side[1],i]
                         if diff1<0:
                             chan2 = side[0]
                             d2 = numpy.abs(diff1)
                             chan1 = side[1]
                             d1 = numpy.abs(diff2)
                         else:
                             chan2 = side[1]
                             d2 = numpy.abs(diff2)
                             chan1 = side[0]
                             d1 = numpy.abs(diff1)
                         if i==0:
                             chanCX = chanC
                             chan1X = chan1
                             chan2X = chan2
                             distances[0:2] = numpy.array([d1,d2])
                         else:
                             chanCY = chanC
                             chan1Y = chan1
                             chan2Y = chan2
                             distances[2:4] = numpy.array([d1,d2])
             #         axisXsides = numpy.reshape(axisX[ix,:],4)
             #
             #         channelCentX = int(numpy.intersect1d(pairX[0,:], pairX[1,:])[0])
             #         channelCentY = int(numpy.intersect1d(pairY[0,:], pairY[1,:])[0])
             #
             #         ind25X = numpy.where(pairX[0,:] != channelCentX)[0][0]
             #         ind20X = numpy.where(pairX[1,:] != channelCentX)[0][0]
             #         channel25X = int(pairX[0,ind25X])
             #         channel20X = int(pairX[1,ind20X])
             #         ind25Y = numpy.where(pairY[0,:] != channelCentY)[0][0]
             #         ind20Y = numpy.where(pairY[1,:] != channelCentY)[0][0]
             #         channel25Y = int(pairY[0,ind25Y])
             #         channel20Y = int(pairY[1,ind20Y])
             #         pairslist = [(channelCentX, channel25X),(channelCentX, channel20X),(channelCentY,channel25Y),(channelCentY, channel20Y)]
                     pairslist = [(chanCX, chan1X),(chanCX, chan2X),(chanCY,chan1Y),(chanCY, chan2Y)]
                     return pairslist, distances
             #     def __getAOA(self, phases, pairsList, error, AOAthresh, azimuth):
             #
             #         arrayAOA = numpy.zeros((phases.shape[0],3))
             #         cosdir0, cosdir = self.__getDirectionCosines(phases, pairsList)
             #
             #         arrayAOA[:,:2] = self.__calculateAOA(cosdir, azimuth)
             #         cosDirError = numpy.sum(numpy.abs(cosdir0 - cosdir), axis = 1)
             #         arrayAOA[:,2] = cosDirError
             #
             #         azimuthAngle = arrayAOA[:,0]
             #         zenithAngle = arrayAOA[:,1]
             #
             #         #Setting Error
             #         #Number 3: AOA not fesible
             #         indInvalid = numpy.where(numpy.logical_and((numpy.logical_or(numpy.isnan(zenithAngle), numpy.isnan(azimuthAngle))),error == 0))[0]
             #         error[indInvalid] = 3
             #         #Number 4: Large difference in AOAs obtained from different antenna baselines
             #         indInvalid = numpy.where(numpy.logical_and(cosDirError > AOAthresh,error == 0))[0]
             #         error[indInvalid] = 4
             #         return arrayAOA, error
             #
             #     def __getDirectionCosines(self, arrayPhase, pairsList):
             #
             #         #Initializing some variables
             #         ang_aux = numpy.array([-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8])*2*numpy.pi
             #         ang_aux = ang_aux.reshape(1,ang_aux.size)
             #
             #         cosdir = numpy.zeros((arrayPhase.shape[0],2))
             #         cosdir0 = numpy.zeros((arrayPhase.shape[0],2))
             #
             #
             #         for i in range(2):
             #             #First Estimation
             #             phi0_aux = arrayPhase[:,pairsList[i][0]] + arrayPhase[:,pairsList[i][1]]
             #             #Dealias
             #             indcsi = numpy.where(phi0_aux > numpy.pi)
             #             phi0_aux[indcsi] -= 2*numpy.pi
             #             indcsi = numpy.where(phi0_aux < -numpy.pi)
             #             phi0_aux[indcsi] += 2*numpy.pi
             #             #Direction Cosine 0
             #             cosdir0[:,i] = -(phi0_aux)/(2*numpy.pi*0.5)
             #
             #             #Most-Accurate Second Estimation
             #             phi1_aux =  arrayPhase[:,pairsList[i][0]] - arrayPhase[:,pairsList[i][1]]
             #             phi1_aux = phi1_aux.reshape(phi1_aux.size,1)
             #             #Direction Cosine 1
             #             cosdir1 = -(phi1_aux + ang_aux)/(2*numpy.pi*4.5)
             #
             #             #Searching the correct Direction Cosine
             #             cosdir0_aux = cosdir0[:,i]
             #             cosdir0_aux = cosdir0_aux.reshape(cosdir0_aux.size,1)
             #             #Minimum Distance
             #             cosDiff = (cosdir1 - cosdir0_aux)**2
             #             indcos = cosDiff.argmin(axis = 1)
             #             #Saving Value obtained
             #             cosdir[:,i] = cosdir1[numpy.arange(len(indcos)),indcos]
             #
             #         return cosdir0, cosdir
             #
             #     def __calculateAOA(self, cosdir, azimuth):
             #         cosdirX = cosdir[:,0]
             #         cosdirY = cosdir[:,1]
             #
             #         zenithAngle = numpy.arccos(numpy.sqrt(1 - cosdirX**2 - cosdirY**2))*180/numpy.pi
             #         azimuthAngle = numpy.arctan2(cosdirX,cosdirY)*180/numpy.pi + azimuth #0 deg north, 90 deg east
             #         angles = numpy.vstack((azimuthAngle, zenithAngle)).transpose()
             #
             #         return angles
             #
             #     def __getHeights(self, Ranges, zenith, error, minHeight, maxHeight):
             #
             #         Ramb = 375  #Ramb = c/(2*PRF)
             #         Re = 6371   #Earth Radius
             #         heights = numpy.zeros(Ranges.shape)
             #
             #         R_aux = numpy.array([0,1,2])*Ramb
             #         R_aux = R_aux.reshape(1,R_aux.size)
             #
             #         Ranges = Ranges.reshape(Ranges.size,1)
             #
             #         Ri = Ranges + R_aux
             #         hi = numpy.sqrt(Re**2 + Ri**2 + (2*Re*numpy.cos(zenith*numpy.pi/180)*Ri.transpose()).transpose()) - Re
             #
             #         #Check if there is a height between 70 and 110 km
             #         h_bool = numpy.sum(numpy.logical_and(hi > minHeight, hi < maxHeight), axis = 1)
             #         ind_h = numpy.where(h_bool == 1)[0]
             #
             #         hCorr = hi[ind_h, :]
             #         ind_hCorr = numpy.where(numpy.logical_and(hi > minHeight, hi < maxHeight))
             #
             #         hCorr = hi[ind_hCorr]
             #         heights[ind_h] = hCorr
             #
             #         #Setting Error
             #         #Number 13: Height unresolvable echo: not valid height within 70 to 110 km
             #         #Number 14: Height ambiguous echo: more than one possible height within 70 to 110 km
             #
             #         indInvalid2 = numpy.where(numpy.logical_and(h_bool > 1, error == 0))[0]
             #         error[indInvalid2] = 14
             #         indInvalid1 = numpy.where(numpy.logical_and(h_bool == 0, error == 0))[0]
             #         error[indInvalid1] = 13
             #
             #         return heights, error
   No newline at end of file

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