schain Commit - r1062:8048843f4edf · Jicamarca Repository

Fix publish and plots operations issue #929

Juan C. Espinoza -

r1062:8048843f4edf

parent child

Context file:

r1062:8048843f4edf

Collapse all files

schainpy/model/data/jrodata.py +1 -1

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy import cSchain
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real','<i1'),('imag','<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real','<i2'),('imag','<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real','<i4'),('imag','<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real','<i8'),('imag','<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real','<f4'),('imag','<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real','<f8'),('imag','<f8')])
                 else:
                     raise ValueError, 'dataTypeCode was not defined'
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real','<i1'),('imag','<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real','<i2'),('imag','<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real','<i4'),('imag','<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real','<i8'),('imag','<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real','<f4'),('imag','<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real','<f8'),('imag','<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
                 sortdata = numpy.sort(data, axis=None)
             #     lenOfData = len(sortdata)
             #     nums_min = lenOfData*0.2
             #
             #     if nums_min <= 5:
             #         nums_min = 5
             #
             #     sump = 0.
             #
             #     sumq = 0.
             #
             #     j = 0
             #
             #     cont = 1
             #
             #     while((cont==1)and(j<lenOfData)):
             #
             #         sump += sortdata[j]
             #
             #         sumq += sortdata[j]**2
             #
             #         if j > nums_min:
             #             rtest = float(j)/(j-1) + 1.0/navg
             #             if ((sumq*j) > (rtest*sump**2)):
             #                 j = j - 1
             #                 sump  = sump - sortdata[j]
             #                 sumq =  sumq - sortdata[j]**2
             #                 cont = 0
             #
             #         j += 1
             #
             #     lnoise = sump /j
             #
             #     return lnoise
                 return cSchain.hildebrand_sekhon(sortdata, navg)
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         attribute = inputObj.__dict__[key]
                         #If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         #If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
             class JROData(GenericData):
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None #dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #
             #     nBaud = None
             #
             #     code = None
                 flagDecodeData = False #asumo q la data no esta decodificada
                 flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 def getNoise(self):
                     raise NotImplementedError
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDeltaH(self):
                     delta = self.heightList[1] - self.heightList[0]
                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval+1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6)*self.getDeltaH()/(0.15)
                     PRF = 1./(period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C/self.frequency
                     vmax = self.getFmax() * _lambda/2
                     return vmax
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False    #Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 def getNoisebyHildebrand(self, channel = None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel,:].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type = 1, channel = None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel = None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10*numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 #data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data dc es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 #data power
                 data_pwr = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,xmin_index:xmax_index,ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
                     else:
                         noise = self.getNoisebyHildebrand(xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints*self.ippFactor)
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10./(self.getFmax() / (self.nFFTPoints*self.ippFactor))
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints*self.ippFactor)
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) #- deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     return normFactor
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles
                     return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10*numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError, "Pair %s is not in dataOut.pairsList" %(pair)
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real)*180/numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print "This property should not be initialized"
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue, "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue, "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt*self.nCohInt*pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNoise(self, type = 1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 #--------------------------------------------------
                 mode = None
                 split = False
                 data_cf = None
                 lags = None
                 lagRange = None
                 pairsList = None
                 normFactor = None
                 #--------------------------------------------------
             #     calculateVelocity = None
                 nLags = None
                 nPairs = None
                 nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode = 2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:,:,indR,:]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1]/2
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
                         ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
                             xx[fil,:] = vel[fil]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                         for ich in range(num_chan):
                             yy = jspectra[ich,ind_vel,:]
                             jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
                             junkid = jspectra[ich,freq_dc,:]<=0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
                     noise = jspectra0[:,freq_dc,:] - jspectra[:,freq_dc,:]
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
                     return timeInterval
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         #Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 def getNormFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs,self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs==ch0,:,:], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs==ch1,:,:], axis=1)
                         normFactor[p,:] = numpy.sqrt(ch0_max*ch1_max)
                     return normFactor
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None   #Information about the experiment
                 #Information from previous data
                 inputUnit = None        #Type of data to be processed
                 operation = None        #Type of operation to parametrize
                 #normFactor = None       #Normalization Factor
                 groupList = None        #List of Pairs, Groups, etc
                 #Parameters
                 data_param = None       #Parameters obtained
                 data_pre = None         #Data Pre Parametrization
                 data_SNR = None         #Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None    #Abscissa, can be velocities, lags or time
             #    noise = None            #Noise Potency
                 utctimeInit = None      #Initial UTC time
                 paramInterval = None    #Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 #Fitting
                 data_error = None       #Error of the estimation
                 constants = None
                 library = None
                 #Output signal
                 outputInterval = None     #Time interval to calculate output signal in seconds
                 data_output = None       #Out signal
                 nAvg = None
                 noise_estimation = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone*60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getTimeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def getNoise(self):
                     return self.spc_noise
                 timeInterval = property(getTimeInterval)

schainpy/model/graphics/jroplot_data.py +513 -695

This diff has been collapsed as it changes many lines, (1208 lines changed) Show them Hide them
	@@ -1,964 +1,782
	1		1
	2	import os	2	import os
	3	import zmq
	4	import time	3	import time
	5	import ~~numpy~~	4	import glob
	6	import datetime	5	import datetime
	7	import numpy as np	6	from multiprocessing import Process
			7
			8	import zmq
			9	import numpy
	8	import matplotlib	10	import matplotlib
	9	import glob
	10	matplotlib.use('TkAgg')
	11	import matplotlib.pyplot as plt	11	import matplotlib.pyplot as plt
	12	from mpl_toolkits.axes_grid1 import make_axes_locatable	12	from mpl_toolkits.axes_grid1 import make_axes_locatable
	13	from matplotlib.ticker import FuncFormatter, LinearLocator	13	from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
	14	from multiprocessing import Process
	15		14
	16	from schainpy.model.proc.jroproc_base import Operation	15	from schainpy.model.proc.jroproc_base import Operation
	17		16	from schainpy.utils import log
	18	plt.ion()
	19		17
	20	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))	18	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))
	21	fromtimestamp = lambda x, mintime : (datetime.datetime.utcfromtimestamp(mintime).replace(hour=(x + 5), minute=0) - d1970).total_seconds()
	22		19
			20	d1970 = datetime.datetime(1970, 1, 1)
	23		21
	24	d1970 = datetime.datetime(1970,1,1)
	25		22
	26	class PlotData(Operation, Process):	23	class PlotData(Operation, Process):
			24	'''
			25	Base class for Schain plotting operations
			26	'''
	27		27
	28	CODE = 'Figure'	28	CODE = 'Figure'
	29	colormap = 'jro'	29	colormap = 'jro'
			30	bgcolor = 'white'
	30	CONFLATE = False	31	CONFLATE = False
	31	__MAXNUMX = 80	32	__MAXNUMX = 80
	32	__missing = 1E30	33	__missing = 1E30
	33		34
	34	def __init__(self, **kwargs):	35	def __init__(self, **kwargs):
	35		36
	36	Operation.__init__(self, plot=True, **kwargs)	37	Operation.__init__(self, plot=True, **kwargs)
	37	Process.__init__(self)	38	Process.__init__(self)
	38	self.kwargs['code'] = self.CODE	39	self.kwargs['code'] = self.CODE
	39	self.mp = False	40	self.mp = False
	40	self.data~~Out~~ = None	41	self.data = None
	41	self.isConfig = False	42	self.isConfig = False
	42	self.figure = ~~None~~	43	self.figures = []
	43	self.axes = []	44	self.axes = []
			45	self.cb_axes = []
	44	self.localtime = kwargs.pop('localtime', True)	46	self.localtime = kwargs.pop('localtime', True)
	45	self.show = kwargs.get('show', True)	47	self.show = kwargs.get('show', True)
	46	self.save = kwargs.get('save', False)	48	self.save = kwargs.get('save', False)
	47	self.colormap = kwargs.get('colormap', self.colormap)	49	self.colormap = kwargs.get('colormap', self.colormap)
	48	self.colormap_coh = kwargs.get('colormap_coh', 'jet')	50	self.colormap_coh = kwargs.get('colormap_coh', 'jet')
	49	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')	51	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
	50	self.~~showprofile~~ = kwargs.get('~~showprofile~~', ~~Tru~~e)	52	self.colormaps = kwargs.get('colormaps', None)
	51	self.~~title~~ = kwargs.get('~~wintitle~~', '')	53	self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
			54	self.showprofile = kwargs.get('showprofile', False)
			55	self.title = kwargs.get('wintitle', self.CODE.upper())
			56	self.cb_label = kwargs.get('cb_label', None)
			57	self.cb_labels = kwargs.get('cb_labels', None)
	52	self.xaxis = kwargs.get('xaxis', 'frequency')	58	self.xaxis = kwargs.get('xaxis', 'frequency')
	53	self.zmin = kwargs.get('zmin', None)	59	self.zmin = kwargs.get('zmin', None)
	54	self.zmax = kwargs.get('zmax', None)	60	self.zmax = kwargs.get('zmax', None)
			61	self.zlimits = kwargs.get('zlimits', None)
	55	self.xmin = kwargs.get('xmin', None)	62	self.xmin = kwargs.get('xmin', None)
			63	if self.xmin is not None:
			64	self.xmin += 5
	56	self.xmax = kwargs.get('xmax', None)	65	self.xmax = kwargs.get('xmax', None)
	57	self.xrange = kwargs.get('xrange', 24)	66	self.xrange = kwargs.get('xrange', 24)
	58	self.ymin = kwargs.get('ymin', None)	67	self.ymin = kwargs.get('ymin', None)
	59	self.ymax = kwargs.get('ymax', None)	68	self.ymax = kwargs.get('ymax', None)
	60	self.~~__MAXNUMY~~ = kwargs.get('~~decimation~~', ~~5000~~)	69	self.xlabel = kwargs.get('xlabel', None)
	61	self.throttle_value = 5	70	self.__MAXNUMY = kwargs.get('decimation', 100)
	62	self.times = []	71	self.showSNR = kwargs.get('showSNR', False)
	63	#self.interactive = self.kwargs['parent']	72	self.oneFigure = kwargs.get('oneFigure', True)
			73	self.width = kwargs.get('width', None)
			74	self.height = kwargs.get('height', None)
			75	self.colorbar = kwargs.get('colorbar', True)
			76	self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
			77	self.titles = ['' for __ in range(16)]
			78
			79	def __setup(self):
			80	'''
			81	Common setup for all figures, here figures and axes are created
			82	'''
			83
			84	self.setup()
			85
			86	if self.width is None:
			87	self.width = 8
	64		88
			89	self.figures = []
			90	self.axes = []
			91	self.cb_axes = []
			92	self.pf_axes = []
			93	self.cmaps = []
			94
			95	size = '15%' if self.ncols==1 else '30%'
			96	pad = '4%' if self.ncols==1 else '8%'
			97
			98	if self.oneFigure:
			99	if self.height is None:
			100	self.height = 1.4*self.nrows + 1
			101	fig = plt.figure(figsize=(self.width, self.height),
			102	edgecolor='k',
			103	facecolor='w')
			104	self.figures.append(fig)
			105	for n in range(self.nplots):
			106	ax = fig.add_subplot(self.nrows, self.ncols, n+1)
			107	ax.tick_params(labelsize=8)
			108	ax.firsttime = True
			109	self.axes.append(ax)
			110	if self.showprofile:
			111	cax = self.__add_axes(ax, size=size, pad=pad)
			112	cax.tick_params(labelsize=8)
			113	self.pf_axes.append(cax)
			114	else:
			115	if self.height is None:
			116	self.height = 3
			117	for n in range(self.nplots):
			118	fig = plt.figure(figsize=(self.width, self.height),
			119	edgecolor='k',
			120	facecolor='w')
			121	ax = fig.add_subplot(1, 1, 1)
			122	ax.tick_params(labelsize=8)
			123	ax.firsttime = True
			124	self.figures.append(fig)
			125	self.axes.append(ax)
			126	if self.showprofile:
			127	cax = self.__add_axes(ax, size=size, pad=pad)
			128	cax.tick_params(labelsize=8)
			129	self.pf_axes.append(cax)
			130
			131	for n in range(self.nrows):
			132	if self.colormaps is not None:
			133	cmap = plt.get_cmap(self.colormaps[n])
			134	else:
			135	cmap = plt.get_cmap(self.colormap)
			136	cmap.set_bad(self.bgcolor, 1.)
			137	self.cmaps.append(cmap)
			138
			139	def __add_axes(self, ax, size='30%', pad='8%'):
	65	'''	140	'''
	66	this new parameter is created to plot data from varius channels at different figures	141	Add new axes to the given figure
	67	1. crear una lista de figuras donde se puedan plotear las figuras,
	68	2. dar las opciones de configuracion a cada figura, estas opciones son iguales para ambas figuras
	69	3. probar?
	70	'''	142	'''
	71	self.ind_plt_ch = kwargs.get('ind_plt_ch', False)	143	divider = make_axes_locatable(ax)
	72	self.figurelist = None	144	nax = divider.new_horizontal(size=size, pad=pad)
			145	ax.figure.add_axes(nax)
			146	return nax
	73		147
	74		148
	75	def fill_gaps(self, x_buffer, y_buffer, z_buffer):	149	def setup(self):
			150	'''
			151	This method should be implemented in the child class, the following
			152	attributes should be set:
			153
			154	self.nrows: number of rows
			155	self.ncols: number of cols
			156	self.nplots: number of plots (channels or pairs)
			157	self.ylabel: label for Y axes
			158	self.titles: list of axes title
			159
			160	'''
			161	raise(NotImplementedError, 'Implement this method in child class')
	76		162
			163	def fill_gaps(self, x_buffer, y_buffer, z_buffer):
			164	'''
			165	Create a masked array for missing data
			166	'''
	77	if x_buffer.shape[0] < 2:	167	if x_buffer.shape[0] < 2:
	78	return x_buffer, y_buffer, z_buffer	168	return x_buffer, y_buffer, z_buffer
	79		169
	80	deltas = x_buffer[1:] - x_buffer[0:-1]	170	deltas = x_buffer[1:] - x_buffer[0:-1]
	81	x_median = np.median(deltas)	171	x_median = numpy.median(deltas)
	82		172
	83	index = np.where(deltas > 5*x_median)	173	index = numpy.where(deltas > 5*x_median)
	84		174
	85	if len(index[0]) != 0:	175	if len(index[0]) != 0:
	86	z_buffer[::, index[0], ::] = self.__missing	176	z_buffer[::, index[0], ::] = self.__missing
	87	z_buffer = np.ma.masked_inside(z_buffer,	177	z_buffer = numpy.ma.masked_inside(z_buffer,
	88	0.99*self.__missing,	178	0.99*self.__missing,
	89	1.01*self.__missing)	179	1.01*self.__missing)
	90		180
	91	return x_buffer, y_buffer, z_buffer	181	return x_buffer, y_buffer, z_buffer
	92		182
	93	def decimate(self):	183	def decimate(self):
	94		184
	95	# dx = int(len(self.x)/self.__MAXNUMX) + 1	185	# dx = int(len(self.x)/self.__MAXNUMX) + 1
	96	dy = int(len(self.y)/self.__MAXNUMY) + 1	186	dy = int(len(self.y)/self.__MAXNUMY) + 1
	97		187
	98	# x = self.x[::dx]	188	# x = self.x[::dx]
	99	x = self.x	189	x = self.x
	100	y = self.y[::dy]	190	y = self.y[::dy]
	101	z = self.z[::, ::, ::dy]	191	z = self.z[::, ::, ::dy]
	102		192
	103	return x, y, z	193	return x, y, z
	104		194
	105	'''	195	def format(self):
	106	JM:	196	'''
	107	elimana las otras imagenes generadas debido a que lso workers no llegan en orden y le pueden	197	Set min and max values, labels, ticks and titles
	108	poner otro tiempo a la figura q no necesariamente es el ultimo.	198	'''
	109	Solo se realiza cuando termina la imagen.
	110	Problemas:
	111		199
	112	File "/home/ci-81/workspace/schainv2.3/schainpy/model/graphics/jroplot_data.py", line 145, in __plot	200	if self.xmin is None:
	113	for n, eachfigure in enumerate(self.figurelist):	201	xmin = self.min_time
	114	TypeError: 'NoneType' object is not iterable	202	else:
			203	if self.xaxis is 'time':
			204	dt = datetime.datetime.fromtimestamp(self.min_time)
			205	xmin = (datetime.datetime.combine(dt.date(),
			206	datetime.time(int(self.xmin), 0, 0))-d1970).total_seconds()
			207	else:
			208	xmin = self.xmin
	115		209
	116	'''	210	if self.xmax is None:
	117	def deleteanotherfiles(self):	211	xmax = xmin+self.xrange6060
	118	figurenames=[]	212	else:
	119	if self.figurelist != None:	213	if self.xaxis is 'time':
	120	for n, eachfigure in enumerate(self.figurelist):	214	dt = datetime.datetime.fromtimestamp(self.min_time)
	121	#add specific name for each channel in channelList	215	xmax = (datetime.datetime.combine(dt.date(),
	122	ghostfigname = os.path.join(self.save, '{}_{}_{}'.format(self.titles[n].replace(' ',''),self.CODE,	216	datetime.time(int(self.xmax), 0, 0))-d1970).total_seconds()
	123	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))	217	else:
	124	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,	218	xmax = self.xmax
	125	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	219
	126		220	ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
	127	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	221	ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
	128	if ghostfigure != figname:	222
	129	os.remove(ghostfigure)	223	ystep = 200 if ymax>= 800 else 100 if ymax>=400 else 50 if ymax>=200 else 20
	130	print 'Removing GhostFigures:' , figname	224
	131	else :	225	for n, ax in enumerate(self.axes):
	132	'''Erasing ghost images for just on******************'''	226	if ax.firsttime:
	133	ghostfigname = os.path.join(self.save, '{}_{}'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))	227	ax.set_facecolor(self.bgcolor)
	134	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	228	ax.yaxis.set_major_locator(MultipleLocator(ystep))
	135	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	229	if self.xaxis is 'time':
	136	if ghostfigure != figname:	230	ax.xaxis.set_major_formatter(FuncFormatter(func))
	137	os.remove(ghostfigure)	231	ax.xaxis.set_major_locator(LinearLocator(9))
	138	print 'Removing GhostFigures:' , figname	232	if self.xlabel is not None:
			233	ax.set_xlabel(self.xlabel)
			234	ax.set_ylabel(self.ylabel)
			235	ax.firsttime = False
			236	if self.showprofile:
			237	self.pf_axes[n].set_ylim(ymin, ymax)
			238	self.pf_axes[n].set_xlim(self.zmin, self.zmax)
			239	self.pf_axes[n].set_xlabel('dB')
			240	self.pf_axes[n].grid(b=True, axis='x')
			241	[tick.set_visible(False) for tick in self.pf_axes[n].get_yticklabels()]
			242	if self.colorbar:
			243	cb = plt.colorbar(ax.plt, ax=ax, pad=0.02)
			244	cb.ax.tick_params(labelsize=8)
			245	if self.cb_label:
			246	cb.set_label(self.cb_label, size=8)
			247	elif self.cb_labels:
			248	cb.set_label(self.cb_labels[n], size=8)
			249
			250	ax.set_title('{} - {} UTC'.format(
			251	self.titles[n],
			252	datetime.datetime.fromtimestamp(self.max_time).strftime('%H:%M:%S')),
			253	size=8)
			254	ax.set_xlim(xmin, xmax)
			255	ax.set_ylim(ymin, ymax)
			256
	139		257
	140	def __plot(self):	258	def __plot(self):
	141		259	'''
	142	print 'plotting...{}'.format(self.CODE)	260	'''
	143	if self.ind_plt_ch is False : #standard	261	log.success('Plotting', self.name)
			262
			263	self.plot()
			264	self.format()
			265
			266	for n, fig in enumerate(self.figures):
			267	if self.nrows == 0 or self.nplots == 0:
			268	log.warning('No data', self.name)
			269	continue
	144	if self.show:	270	if self.show:
	145	~~self~~.fig~~ure~~.show()	271	fig.show()
	146	~~self~~.~~plot~~()	272
	147	~~plt~~.tight_layout()	273	fig.tight_layout()
	148	~~self~~.fig~~ure~~.canvas.manager.set_window_title('{} {} - {}'.format(self.title, ~~self~~.~~CODE~~.~~upper(),~~	274	fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
	149	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	275	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))
	150	else :	276	# fig.canvas.draw()
	151	print 'len(self.figurelist): ',len(self.figurelist)	277
	152	for n, eachfigure in enumerate(self.figurelist):	278	if self.save and self.data.ended:
	153	if self.~~show~~:	279	channels = range(self.nrows)
	154	~~eachfigure~~.~~show~~()	280	if self.oneFigure:
	155		281	label = ''
	156	~~self~~.~~plot~~()	282	else:
	157	eachfigure.tight_layout() # ajuste de cada subplot	283	label = '_{}'.format(channels[n])
	158	eachfigure.canvas.manager.set_window_title('{} {} - {}'.format(self.title[n], self.CODE.upper(),	284	figname = os.path.join(
	159	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	285	self.save,
	160		286	'{}{}_{}.png'.format(
	161	# if self.save:	287	self.CODE,
	162	# if self.ind_plt_ch is False : #standard	288	label,
	163	# figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,	289	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')
	164	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	290	)
	165	# print 'Saving figure: {}'.format(figname)	291	)
	166	# self.figure.savefig(figname)
	167	# else :
	168	# for n, eachfigure in enumerate(self.figurelist):
	169	# #add specific name for each channel in channelList
	170	# figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n],self.CODE,
	171	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	172	#
	173	# print 'Saving figure: {}'.format(figname)
	174	# eachfigure.savefig(figname)
	175
	176	if self.ind_plt_ch is False :
	177	self.figure.canvas.draw()
	178	else :
	179	for eachfigure in self.figurelist:
	180	eachfigure.canvas.draw()
	181
	182	if self.save:
	183	if self.ind_plt_ch is False : #standard
	184	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,
	185	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	186	print 'Saving figure: {}'.format(figname)	292	print 'Saving figure: {}'.format(figname)
	187	~~self~~.fig~~ure~~.savefig(figname)	293	fig.savefig(figname)
	188	else :
	189	for n, eachfigure in enumerate(self.figurelist):
	190	#add specific name for each channel in channelList
	191	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,
	192	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	193
	194	print 'Saving figure: {}'.format(figname)
	195	eachfigure.savefig(figname)
	196
	197		294
	198	def plot(self):	295	def plot(self):
	199		296	'''
	200	print 'plotting...{}'.format(self.CODE.upper())	297	'''
	201	return	298	raise(NotImplementedError, 'Implement this method in child class')
	202		299
	203	def run(self):	300	def run(self):
	204		301
	205	~~print~~ ~~'[Starting] {}'~~.~~format~~(self.name)	302	log.success('Starting', self.name)
	206		303
	207	context = zmq.Context()	304	context = zmq.Context()
	208	receiver = context.socket(zmq.SUB)	305	receiver = context.socket(zmq.SUB)
	209	receiver.setsockopt(zmq.SUBSCRIBE, '')	306	receiver.setsockopt(zmq.SUBSCRIBE, '')
	210	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)	307	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
	211		308
	212	if 'server' in self.kwargs['parent']:	309	if 'server' in self.kwargs['parent']:
	213	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))	310	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
	214	else:	311	else:
	215	receiver.connect("ipc:///tmp/zmq.plots")	312	receiver.connect("ipc:///tmp/zmq.plots")
	216
	217	seconds_passed = 0
	218		313
	219	while True:	314	while True:
	220	try:	315	try:
	221	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)~~#flags=zmq.NOBLOCK~~	316	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
	222	self.started = self.data['STARTED']	317
	223	self.~~dataOut~~ = self.data[~~'dataOut'~~]	318	self.min_time = self.data.times[0]
	224		319	self.max_time = self.data.times[-1]
	225	if (len(self.times) < len(self.data['times']) and not self.started and self.data['ENDED']):
	226	continue
	227
	228	self.times = self.data['times']
	229	self.times.sort()
	230	self.throttle_value = self.data['throttle']
	231	self.min_time = self.times[0]
	232	self.max_time = self.times[-1]
	233		320
	234	if self.isConfig is False:	321	if self.isConfig is False:
	235	~~print~~ ~~'setting up'~~	322	self.__setup()
	236	self.setup()
	237	self.isConfig = True	323	self.isConfig = True
	238	self.__plot()	324
	239		325	self.__plot()
	240	if self.data['ENDED'] is True:
	241	print '******GRAPHIC ENDED******'
	242	self.ended = True
	243	self.isConfig = False
	244	self.__plot()
	245	self.deleteanotherfiles() #CLPDG
	246	elif seconds_passed >= self.data['throttle']:
	247	print 'passed', seconds_passed
	248	self.__plot()
	249	seconds_passed = 0
	250		326
	251	except zmq.Again as e:	327	except zmq.Again as e:
	252	~~print~~ 'Waiting for data...'	328	log.log('Waiting for data...')
	253	~~plt~~.~~pause~~(2)	329	if self.data:
	254	seconds_passed += 2	330	plt.pause(self.data.throttle)
			331	else:
			332	time.sleep(2)
	255		333
	256	def close(self):	334	def close(self):
	257	if self.data~~Out~~:	335	if self.data:
	258	self.__plot()	336	self.__plot()
	259		337
	260		338
	261	class PlotSpectraData(PlotData):	339	class PlotSpectraData(PlotData):
			340	'''
			341	Plot for Spectra data
			342	'''
	262		343
	263	CODE = 'spc'	344	CODE = 'spc'
	264	colormap = 'jro'	345	colormap = 'jro'
	265	CONFLATE = False
	266		346
	267	def setup(self):	347	def setup(self):
	268		348	self.nplots = len(self.data.channels)
	269	ncolspan = 1	349	self.ncols = int(numpy.sqrt(self.nplots)+ 0.9)
	270	colspan = 1	350	self.nrows = int((1.0*self.nplots/self.ncols) + 0.9)
	271	self.ncols = int(numpy.sqrt(self.dataOut.nChannels)+0.9)	351	self.width = 3.4*self.ncols
	272	self.nrows = int(self.dataOut.nChannels*1./self.ncols + 0.9)	352	self.height = 3*self.nrows
	273	self.width = 3.6*self.ncols	353	self.cb_label = 'dB'
	274	self.height = 3.2*self.nrows	354	if self.showprofile:
	275	if self.showprofile:	355	self.width += 0.8*self.ncols
	276	ncolspan = 3
	277	colspan = 2
	278	self.width += 1.2*self.ncols
	279		356
	280	self.ylabel = 'Range [Km]'	357	self.ylabel = 'Range [Km]'
	281	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]
	282
	283	if self.figure is None:
	284	self.figure = plt.figure(figsize=(self.width, self.height),
	285	edgecolor='k',
	286	facecolor='w')
	287	else:
	288	self.figure.clf()
	289
	290	n = 0
	291	for y in range(self.nrows):
	292	for x in range(self.ncols):
	293	if n >= self.dataOut.nChannels:
	294	break
	295	ax = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan), 1, colspan)
	296	if self.showprofile:
	297	ax.ax_profile = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan+colspan), 1, 1)
	298
	299	ax.firsttime = True
	300	self.axes.append(ax)
	301	n += 1
	302		358
	303	def plot(self):	359	def plot(self):
	304
	305	if self.xaxis == "frequency":	360	if self.xaxis == "frequency":
	306	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	361	x = self.data.xrange[0]
	307	xlabel = "Frequency (kHz)"	362	self.xlabel = "Frequency (kHz)"
	308	elif self.xaxis == "time":	363	elif self.xaxis == "time":
	309	x = self.data~~Out~~.~~getAcfRange~~(1)	364	x = self.data.xrange[1]
	310	xlabel = "Time (ms)"	365	self.xlabel = "Time (ms)"
	311	else:	366	else:
	312	x = self.data~~Out~~.~~getVelRange~~(1)	367	x = self.data.xrange[2]
	313	xlabel = "Velocity (m/s)"	368	self.xlabel = "Velocity (m/s)"
			369
			370	if self.CODE == 'spc_mean':
			371	x = self.data.xrange[2]
			372	self.xlabel = "Velocity (m/s)"
	314		373
	315	y = self.dataOut.getHeiRange()	374	self.titles = []
	316	z = self.data[self.CODE]
	317		375
			376	y = self.data.heights
			377	self.y = y
			378	z = self.data['spc']
			379
	318	for n, ax in enumerate(self.axes):	380	for n, ax in enumerate(self.axes):
			381	noise = self.data['noise'][n][-1]
			382	if self.CODE == 'spc_mean':
			383	mean = self.data['mean'][n][-1]
	319	if ax.firsttime:	384	if ax.firsttime:
	320	self.xmax = self.xmax if self.xmax else np.nanmax(x)	385	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	321	self.xmin = self.xmin if self.xmin else -self.xmax	386	self.xmin = self.xmin if self.xmin else -self.xmax
	322	self.ymin = self.ymin if self.ymin else np.nanmin(y)	387	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	323	self.ymax = self.ymax if self.ymax else np.nanmax(y)	388	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	324	self.zmin = self.zmin if self.zmin else np.nanmin(z)	389	ax.plt = ax.pcolormesh(x, y, z[n].T,
	325	self.zmax = self.zmax if self.zmax else np.nanmax(z)	390	vmin=self.zmin,
	326	ax.plot = ax.pcolormesh(x, y, z[n].T,	391	vmax=self.zmax,
	327	~~vmin~~=self.~~zmin~~,	392	cmap=plt.get_cmap(self.colormap)
	328	~~vmax~~=~~self~~.~~zmax~~,	393	)
	329	cmap=plt.get_cmap(self.colormap)
	330	)
	331	divider = make_axes_locatable(ax)
	332	cax = divider.new_horizontal(size='3%', pad=0.05)
	333	self.figure.add_axes(cax)
	334	plt.colorbar(ax.plot, cax)
	335
	336	ax.set_xlim(self.xmin, self.xmax)
	337	ax.set_ylim(self.ymin, self.ymax)
	338
	339	ax.set_ylabel(self.ylabel)
	340	ax.set_xlabel(xlabel)
	341
	342	ax.firsttime = False
	343		394
	344	if self.showprofile:	395	if self.showprofile:
	345	ax.plot_profile= ax.~~ax_profile~~.plot(self.data['rti'][~~self~~.~~max_time~~][n], y)[0]	396	ax.plt_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], y)[0]
	346	ax.ax_profile.set_xlim(self.zmin, self.zmax)	397	ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
	347	ax.ax_profile.set_ylim(self.ymin, self.ymax)	398	color="k", linestyle="dashed", lw=1)[0]
	348	ax.ax_profile.set_xlabel('dB')	399	if self.CODE == 'spc_mean':
	349	ax.ax_profile.grid(b=True, axis='x')	400	ax.plt_mean = ax.plot(mean, y, color='k')[0]
	350	ax.plot_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,
	351	color="k", linestyle="dashed", lw=2)[0]
	352	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	353	else:	401	else:
	354	ax.plot.set_array(z[n].T.ravel())	402	ax.plt.set_array(z[n].T.ravel())
	355	if self.showprofile:	403	if self.showprofile:
	356	ax.plot_profile.set_data(self.data['rti'][~~self~~.~~max_time~~][n], y)	404	ax.plt_profile.set_data(self.data['rti'][n][-1], y)
	357	ax.plot_noise.set_data(numpy.repeat(~~self~~.~~data~~['noise'][~~self~~.~~max_time~~][n], len(y)), y)	405	ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
			406	if self.CODE == 'spc_mean':
			407	ax.plt_mean.set_data(mean, y)
	358		408
	359	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),	409	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	360	size=8)
	361	self.saveTime = self.max_time	410	self.saveTime = self.max_time
	362		411
	363		412
	364	class PlotCrossSpectraData(PlotData):	413	class PlotCrossSpectraData(PlotData):
	365		414
	366	CODE = 'cspc'	415	CODE = 'cspc'
	367	zmin_coh = None	416	zmin_coh = None
	368	zmax_coh = None	417	zmax_coh = None
	369	zmin_phase = None	418	zmin_phase = None
	370	zmax_phase = None	419	zmax_phase = None
	371	CONFLATE = False
	372		420
	373	def setup(self):	421	def setup(self):
	374		422
	375	ncols~~pan~~ = 1	423	self.ncols = 4
	376	colspan = 1	424	self.nrows = len(self.data.pairs)
	377	self.n~~col~~s = 2	425	self.nplots = self.nrows*4
	378	self.~~nrows~~ = self.~~dataOut~~.~~nPair~~s	426	self.width = 3.4*self.ncols
	379	self.~~width~~ = 3.6*self.n~~col~~s	427	self.height = 3*self.nrows
	380	self.height = 3.2*self.nrows
	381
	382	self.ylabel = 'Range [Km]'	428	self.ylabel = 'Range [Km]'
	383	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	429	self.showprofile = False
	384
	385	if self.figure is None:
	386	self.figure = plt.figure(figsize=(self.width, self.height),
	387	edgecolor='k',
	388	facecolor='w')
	389	else:
	390	self.figure.clf()
	391
	392	for y in range(self.nrows):
	393	for x in range(self.ncols):
	394	ax = plt.subplot2grid((self.nrows, self.ncols), (y, x), 1, 1)
	395	ax.firsttime = True
	396	self.axes.append(ax)
	397		430
	398	def plot(self):	431	def plot(self):
	399		432
	400	if self.xaxis == "frequency":	433	if self.xaxis == "frequency":
	401	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	434	x = self.data.xrange[0]
	402	xlabel = "Frequency (kHz)"	435	self.xlabel = "Frequency (kHz)"
	403	elif self.xaxis == "time":	436	elif self.xaxis == "time":
	404	x = self.data~~Out~~.~~getAcfRange~~(1)	437	x = self.data.xrange[1]
	405	xlabel = "Time (ms)"	438	self.xlabel = "Time (ms)"
	406	else:	439	else:
	407	x = self.data~~Out~~.~~getVelRange~~(1)	440	x = self.data.xrange[2]
	408	xlabel = "Velocity (m/s)"	441	self.xlabel = "Velocity (m/s)"
			442
			443	self.titles = []
	409		444
	410	y = self.data~~Out~~.~~getHeiRange~~()	445	y = self.data.heights
	411	z_coh = self.data['cspc_coh']	446	self.y = y
	412	~~z_phase~~ = self.data['cspc~~_phase~~']	447	spc = self.data['spc']
			448	cspc = self.data['cspc']
	413		449
	414	for n in range(self.nrows):	450	for n in range(self.nrows):
	415	ax = self.~~axes~~[2*n]	451	noise = self.data['noise'][n][-1]
	416	~~ax1~~ = self.~~axe~~s[2*n+1]	452	pair = self.data.pairs[n]
			453	ax = self.axes[4*n]
			454	ax3 = self.axes[4*n+3]
	417	if ax.firsttime:	455	if ax.firsttime:
	418	self.xmax = self.xmax if self.xmax else np.nanmax(x)	456	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	419	self.xmin = self.xmin if self.xmin else -self.xmax	457	self.xmin = self.xmin if self.xmin else -self.xmax
	420	self.ymin = self.ymin if self.ymin else np.nanmin(y)	458	self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
	421	self.ymax = self.ymax if self.ymax else np.nanmax(y)	459	self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
	422	self.zmin_coh = self.zmin_coh if self.zmin_coh else 0.0	460	ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
	423	self.zmax_coh = self.zmax_coh if self.zmax_coh else 1.0	461	vmin=self.zmin,
	424	self.zmin_phase = self.zmin_phase if self.zmin_phase else -180	462	vmax=self.zmax,
	425	self.zmax_phase = self.zmax_phase if self.zmax_phase else 180	463	cmap=plt.get_cmap(self.colormap)
	426		464	)
	427	ax.plot = ax.pcolormesh(x, y, z_coh[n].T,
	428	vmin=self.zmin_coh,
	429	vmax=self.zmax_coh,
	430	cmap=plt.get_cmap(self.colormap_coh)
	431	)
	432	divider = make_axes_locatable(ax)
	433	cax = divider.new_horizontal(size='3%', pad=0.05)
	434	self.figure.add_axes(cax)
	435	plt.colorbar(ax.plot, cax)
	436
	437	ax.set_xlim(self.xmin, self.xmax)
	438	ax.set_ylim(self.ymin, self.ymax)
	439
	440	ax.set_ylabel(self.ylabel)
	441	ax.set_xlabel(xlabel)
	442	ax.firsttime = False
	443
	444	ax1.plot = ax1.pcolormesh(x, y, z_phase[n].T,
	445	vmin=self.zmin_phase,
	446	vmax=self.zmax_phase,
	447	cmap=plt.get_cmap(self.colormap_phase)
	448	)
	449	divider = make_axes_locatable(ax1)
	450	cax = divider.new_horizontal(size='3%', pad=0.05)
	451	self.figure.add_axes(cax)
	452	plt.colorbar(ax1.plot, cax)
	453
	454	ax1.set_xlim(self.xmin, self.xmax)
	455	ax1.set_ylim(self.ymin, self.ymax)
	456
	457	ax1.set_ylabel(self.ylabel)
	458	ax1.set_xlabel(xlabel)
	459	ax1.firsttime = False
	460	else:	465	else:
	461	ax.plot.set_array(~~z_coh~~[n].T.ravel())	466	ax.plt.set_array(spc[pair[0]].T.ravel())
	462	ax1.plot.set_array(z_phase[n].T.ravel())	467	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	463
	464	ax.set_title('Coherence Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	465	ax1.set_title('Phase Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	466	self.saveTime = self.max_time
	467
	468		468
	469	class PlotSpectraMeanData(PlotSpectraData):	469	ax = self.axes[4*n+1]
	470		470	if ax.firsttime:
	471	CODE = 'spc_mean'	471	ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
	472	colormap = 'jet'
	473
	474	def plot(self):
	475
	476	if self.xaxis == "frequency":
	477	x = self.dataOut.getFreqRange(1)/1000.
	478	xlabel = "Frequency (kHz)"
	479	elif self.xaxis == "time":
	480	x = self.dataOut.getAcfRange(1)
	481	xlabel = "Time (ms)"
	482	else:
	483	x = self.dataOut.getVelRange(1)
	484	xlabel = "Velocity (m/s)"
	485
	486	y = self.dataOut.getHeiRange()
	487	z = self.data['spc']
	488	mean = self.data['mean'][self.max_time]
	489
	490	for n, ax in enumerate(self.axes):
	491
	492	if ax.firsttime:
	493	self.xmax = self.xmax if self.xmax else np.nanmax(x)
	494	self.xmin = self.xmin if self.xmin else -self.xmax
	495	self.ymin = self.ymin if self.ymin else np.nanmin(y)
	496	self.ymax = self.ymax if self.ymax else np.nanmax(y)
	497	self.zmin = self.zmin if self.zmin else np.nanmin(z)
	498	self.zmax = self.zmax if self.zmax else np.nanmax(z)
	499	ax.plt = ax.pcolormesh(x, y, z[n].T,
	500	vmin=self.zmin,	472	vmin=self.zmin,
	501	vmax=self.zmax,	473	vmax=self.zmax,
	502	cmap=plt.get_cmap(self.colormap)	474	cmap=plt.get_cmap(self.colormap)
	503	)	475	)
	504	ax.plt_dop = ax.plot(mean[n], y,
	505	color='k')[0]
	506
	507	divider = make_axes_locatable(ax)
	508	cax = divider.new_horizontal(size='3%', pad=0.05)
	509	self.figure.add_axes(cax)
	510	plt.colorbar(ax.plt, cax)
	511
	512	ax.set_xlim(self.xmin, self.xmax)
	513	ax.set_ylim(self.ymin, self.ymax)
	514
	515	ax.set_ylabel(self.ylabel)
	516	ax.set_xlabel(xlabel)
	517
	518	ax.firsttime = False
	519
	520	if self.showprofile:
	521	ax.plt_profile= ax.ax_profile.plot(self.data['rti'][self.max_time][n], y)[0]
	522	ax.ax_profile.set_xlim(self.zmin, self.zmax)
	523	ax.ax_profile.set_ylim(self.ymin, self.ymax)
	524	ax.ax_profile.set_xlabel('dB')
	525	ax.ax_profile.grid(b=True, axis='x')
	526	ax.plt_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,
	527	color="k", linestyle="dashed", lw=2)[0]
	528	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	529	else:	476	else:
	530	ax.plt.set_array(z[n].T.ravel())	477	ax.plt.set_array(spc[pair[1]].T.ravel())
	531	ax.plt_dop.set_data(mean[n], y)	478	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	532	if self.showprofile:	479
	533	ax.plt_profile.set_data(self.data['rti'][self.max_time][n], y)	480	out = cspc[n]/numpy.sqrt(spc[pair[0]]*spc[pair[1]])
	534	ax.plt_noise.set_data(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y)	481	coh = numpy.abs(out)
			482	phase = numpy.arctan2(out.imag, out.real)*180/numpy.pi
			483
			484	ax = self.axes[4*n+2]
			485	if ax.firsttime:
			486	ax.plt = ax.pcolormesh(x, y, coh.T,
			487	vmin=0,
			488	vmax=1,
			489	cmap=plt.get_cmap(self.colormap_coh)
			490	)
			491	else:
			492	ax.plt.set_array(coh.T.ravel())
			493	self.titles.append('Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
	535		494
	536	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),	495	ax = self.axes[4*n+3]
	537	size=8)	496	if ax.firsttime:
			497	ax.plt = ax.pcolormesh(x, y, phase.T,
			498	vmin=-180,
			499	vmax=180,
			500	cmap=plt.get_cmap(self.colormap_phase)
			501	)
			502	else:
			503	ax.plt.set_array(phase.T.ravel())
			504	self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
			505
	538	self.saveTime = self.max_time	506	self.saveTime = self.max_time
	539		507
	540		508
			509	class PlotSpectraMeanData(PlotSpectraData):
			510	'''
			511	Plot for Spectra and Mean
			512	'''
			513	CODE = 'spc_mean'
			514	colormap = 'jro'
			515
			516
	541	class PlotRTIData(PlotData):	517	class PlotRTIData(PlotData):
			518	'''
			519	Plot for RTI data
			520	'''
	542		521
	543	CODE = 'rti'	522	CODE = 'rti'
	544	colormap = 'jro'	523	colormap = 'jro'
	545		524
	546	def setup(self):	525	def setup(self):
	547	self.~~ncol~~s = 1	526	self.xaxis = 'time'
	548	self.nrows = self.dataOut.nChannels	527	self.ncols = 1
	549	self.width = 10	528	self.nrows = len(self.data.channels)
	550	#TODO : arreglar la altura de la figura, esta hardcodeada.	529	self.nplots = len(self.data.channels)
	551	#Se arreglo, testear!
	552	if self.ind_plt_ch:
	553	self.height = 3.2#*self.nrows if self.nrows<6 else 12
	554	else:
	555	self.height = 2.2*self.nrows if self.nrows<6 else 12
	556
	557	'''
	558	if self.nrows==1:
	559	self.height += 1
	560	'''
	561	self.ylabel = 'Range [Km]'	530	self.ylabel = 'Range [Km]'
	562	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	531	self.cb_label = 'dB'
	563		532	self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	564	'''
	565	Logica:
	566	1) Si la variable ind_plt_ch es True, va a crear mas de 1 figura
	567	2) guardamos "Figures" en una lista y "axes" en otra, quizas se deberia guardar el
	568	axis dentro de "Figures" como un diccionario.
	569	'''
	570	if self.ind_plt_ch is False: #standard mode
	571
	572	if self.figure is None: #solo para la priemra vez
	573	self.figure = plt.figure(figsize=(self.width, self.height),
	574	edgecolor='k',
	575	facecolor='w')
	576	else:
	577	self.figure.clf()
	578	self.axes = []
	579
	580
	581	for n in range(self.nrows):
	582	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	583	#ax = self.figure(n+1)
	584	ax.firsttime = True
	585	self.axes.append(ax)
	586
	587	else : #append one figure foreach channel in channelList
	588	if self.figurelist == None:
	589	self.figurelist = []
	590	for n in range(self.nrows):
	591	self.figure = plt.figure(figsize=(self.width, self.height),
	592	edgecolor='k',
	593	facecolor='w')
	594	#add always one subplot
	595	self.figurelist.append(self.figure)
	596
	597	else : # cada dia nuevo limpia el axes, pero mantiene el figure
	598	for eachfigure in self.figurelist:
	599	eachfigure.clf() # eliminaria todas las figuras de la lista?
	600	self.axes = []
	601
	602	for eachfigure in self.figurelist:
	603	ax = eachfigure.add_subplot(1,1,1) #solo 1 axis por figura
	604	#ax = self.figure(n+1)
	605	ax.firsttime = True
	606	#Cada figura tiene un distinto puntero
	607	self.axes.append(ax)
	608	#plt.close(eachfigure)
	609
	610		533
	611	def plot(self):	534	def plot(self):
			535	self.x = self.data.times
			536	self.y = self.data.heights
			537	self.z = self.data[self.CODE]
			538	self.z = numpy.ma.masked_invalid(self.z)
	612		539
	613	if self.ind_plt_ch is False: #standard mode	540	for n, ax in enumerate(self.axes):
	614	self.x = np.array(self.times)	541	x, y, z = self.fill_gaps(*self.decimate())
	615	self.y = self.dataOut.getHeiRange()	542	self.zmin = self.zmin if self.zmin else numpy.min(self.z)
	616	self.z = []	543	self.zmax = self.zmax if self.zmax else numpy.max(self.z)
	617		544	if ax.firsttime:
	618	for ch in range(self.nrows):	545	ax.plt = ax.pcolormesh(x, y, z[n].T,
	619	self.z.append([self.data[self.CODE][t][ch] for t in self.times])	546	vmin=self.zmin,
	620		547	vmax=self.zmax,
	621	self.z = np.array(self.z)	548	cmap=plt.get_cmap(self.colormap)
	622	for n, ax in enumerate(self.axes):	549	)
	623	x, y, z = self.fill_gaps(*self.decimate())	550	if self.showprofile:
	624	if self.xmin is None:	551	ax.plot_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], self.y)[0]
	625	xmin = self.min_time	552	ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
	626	else:	553	color="k", linestyle="dashed", lw=1)[0]
	627	xmin = fromtimestamp(int(self.xmin), self.min_time)	554	else:
	628	if self.xmax is None:	555	ax.collections.remove(ax.collections[0])
	629	xmax = xmin + self.xrange6060	556	ax.plt = ax.pcolormesh(x, y, z[n].T,
	630	else:	557	vmin=self.zmin,
	631	xmax = xmin + (self.xmax - self.xmin) * 60 * 60	558	vmax=self.zmax,
	632	self.zmin = self.zmin if self.zmin else np.min(self.z)	559	cmap=plt.get_cmap(self.colormap)
	633	self.zmax = self.zmax if self.zmax else np.max(self.z)	560	)
	634	if ax.~~firsttim~~e:	561	if self.showprofile:
	635	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)	562	ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
	636	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)	563	ax.plot_noise.set_data(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y)
	637	plot = ax.pcolormesh(x, y, z[n].T,
	638	vmin=self.zmin,
	639	vmax=self.zmax,
	640	cmap=plt.get_cmap(self.colormap)
	641	)
	642	divider = make_axes_locatable(ax)
	643	cax = divider.new_horizontal(size='2%', pad=0.05)
	644	self.figure.add_axes(cax)
	645	plt.colorbar(plot, cax)
	646	ax.set_ylim(self.ymin, self.ymax)
	647	ax.xaxis.set_major_formatter(FuncFormatter(func))
	648	ax.xaxis.set_major_locator(LinearLocator(6))
	649	ax.set_ylabel(self.ylabel)
	650	# if self.xmin is None:
	651	# xmin = self.min_time
	652	# else:
	653	# xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	654	# datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	655
	656	ax.set_xlim(xmin, xmax)
	657	ax.firsttime = False
	658	else:
	659	ax.collections.remove(ax.collections[0])
	660	ax.set_xlim(xmin, xmax)
	661	plot = ax.pcolormesh(x, y, z[n].T,
	662	vmin=self.zmin,
	663	vmax=self.zmax,
	664	cmap=plt.get_cmap(self.colormap)
	665	)
	666	ax.set_title('{} {}'.format(self.titles[n],
	667	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	668	size=8)
	669
	670	self.saveTime = self.min_time
	671	else :
	672	self.x = np.array(self.times)
	673	self.y = self.dataOut.getHeiRange()
	674	self.z = []
	675
	676	for ch in range(self.nrows):
	677	self.z.append([self.data[self.CODE][t][ch] for t in self.times])
	678
	679	self.z = np.array(self.z)
	680	for n, eachfigure in enumerate(self.figurelist): #estaba ax in axes
	681
	682	x, y, z = self.fill_gaps(*self.decimate())
	683	xmin = self.min_time
	684	xmax = xmin+self.xrange6060
	685	self.zmin = self.zmin if self.zmin else np.min(self.z)
	686	self.zmax = self.zmax if self.zmax else np.max(self.z)
	687	if self.axes[n].firsttime:
	688	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	689	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	690	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	691	vmin=self.zmin,
	692	vmax=self.zmax,
	693	cmap=plt.get_cmap(self.colormap)
	694	)
	695	divider = make_axes_locatable(self.axes[n])
	696	cax = divider.new_horizontal(size='2%', pad=0.05)
	697	eachfigure.add_axes(cax)
	698	#self.figure2.add_axes(cax)
	699	plt.colorbar(plot, cax)
	700	self.axes[n].set_ylim(self.ymin, self.ymax)
	701
	702	self.axes[n].xaxis.set_major_formatter(FuncFormatter(func))
	703	self.axes[n].xaxis.set_major_locator(LinearLocator(6))
	704
	705	self.axes[n].set_ylabel(self.ylabel)
	706
	707	if self.xmin is None:
	708	xmin = self.min_time
	709	else:
	710	xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	711	datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	712
	713	self.axes[n].set_xlim(xmin, xmax)
	714	self.axes[n].firsttime = False
	715	else:
	716	self.axes[n].collections.remove(self.axes[n].collections[0])
	717	self.axes[n].set_xlim(xmin, xmax)
	718	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	719	vmin=self.zmin,
	720	vmax=self.zmax,
	721	cmap=plt.get_cmap(self.colormap)
	722	)
	723	self.axes[n].set_title('{} {}'.format(self.titles[n],
	724	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	725	size=8)
	726		564
	727	self.saveTime = self.min_time	565	self.saveTime = self.min_time
	728		566
	729		567
	730	class PlotCOHData(PlotRTIData):	568	class PlotCOHData(PlotRTIData):
			569	'''
			570	Plot for Coherence data
			571	'''
	731		572
	732	CODE = 'coh'	573	CODE = 'coh'
	733		574
	734	def setup(self):	575	def setup(self):
	735		576	self.xaxis = 'time'
	736	self.ncols = 1	577	self.ncols = 1
	737	self.nrows = self.data~~Out~~.~~nPairs~~	578	self.nrows = len(self.data.pairs)
	738	self.width = 10	579	self.nplots = len(self.data.pairs)
	739	self.height = 2.2*self.nrows if self.nrows<6 else 12	580	self.ylabel = 'Range [Km]'
	740	self.ind_plt_ch = False #just for coherence and phase	581	if self.CODE == 'coh':
	741	if self.nrows==1:	582	self.cb_label = ''
	742	self.height += 1	583	self.titles = ['Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	743	self.ylabel = 'Range [Km]'
	744	self.titles = ['{} Ch{} * Ch{}'.format(self.CODE.upper(), x[0], x[1]) for x in self.dataOut.pairsList]
	745
	746	if self.figure is None:
	747	self.figure = plt.figure(figsize=(self.width, self.height),
	748	edgecolor='k',
	749	facecolor='w')
	750	else:	584	else:
	751	self.~~figure~~.~~clf~~()	585	self.cb_label = 'Degrees'
	752	self.axes = []	586	self.titles = ['Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	753		587
	754	for n in range(self.nrows):	588
	755	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)	589	class PlotPHASEData(PlotCOHData):
	756	ax.firsttime = True	590	'''
	757	self.axes.append(ax)	591	Plot for Phase map data
			592	'''
			593
			594	CODE = 'phase'
			595	colormap = 'seismic'
	758		596
	759		597
	760	class PlotNoiseData(PlotData):	598	class PlotNoiseData(PlotData):
			599	'''
			600	Plot for noise
			601	'''
			602
	761	CODE = 'noise'	603	CODE = 'noise'
	762		604
	763	def setup(self):	605	def setup(self):
	764		606	self.xaxis = 'time'
	765	self.ncols = 1	607	self.ncols = 1
	766	self.nrows = 1	608	self.nrows = 1
	767	self.~~width~~ = 10	609	self.nplots = 1
	768	self.height = 3.2
	769	self.ylabel = 'Intensity [dB]'	610	self.ylabel = 'Intensity [dB]'
	770	self.titles = ['Noise']	611	self.titles = ['Noise']
	771		612	self.colorbar = False
	772	if self.figure is None:
	773	self.figure = plt.figure(figsize=(self.width, self.height),
	774	edgecolor='k',
	775	facecolor='w')
	776	else:
	777	self.figure.clf()
	778	self.axes = []
	779
	780	self.ax = self.figure.add_subplot(self.nrows, self.ncols, 1)
	781	self.ax.firsttime = True
	782		613
	783	def plot(self):	614	def plot(self):
	784		615
	785	x = self.times	616	x = self.data.times
	786	xmin = self.min_time	617	xmin = self.min_time
	787	xmax = xmin+self.xrange6060	618	xmax = xmin+self.xrange6060
	788	if self.ax.firsttime:	619	Y = self.data[self.CODE]
	789	for ch in self.dataOut.channelList:	620
	790	y = [self.data[self.CODE][t][ch] for t in self.times]	621	if self.axes[0].firsttime:
	791	self.ax.plot(x, y, lw=1, label='Ch{}'.format(ch))	622	for ch in self.data.channels:
	792	self.ax.firsttime = False	623	y = Y[ch]
	793	self.ax.xaxis.set_major_formatter(FuncFormatter(func))	624	self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
	794	self.ax.xaxis.set_major_locator(LinearLocator(6))
	795	self.ax.set_ylabel(self.ylabel)
	796	plt.legend()	625	plt.legend()
	797	else:	626	else:
	798	for ch in self.data~~Out~~.channelList:	627	for ch in self.data.channels:
	799	y = [self.data[self.CODE][t][ch] for t in self.times]	628	y = Y[ch]
	800	self.ax.lines[ch].set_data(x, y)	629	self.axes[0].lines[ch].set_data(x, y)
	801		630
	802	self.ax.set_xlim(xmin, xmax)	631	self.ymin = numpy.nanmin(Y) - 5
	803	self.ax.set_ylim(min(y)-5, max(y)+5)	632	self.ymax = numpy.nanmax(Y) + 5
	804	self.saveTime = self.min_time	633	self.saveTime = self.min_time
	805		634
	806		635
	807	class PlotWindProfilerData(PlotRTIData):
	808
	809	CODE = 'wind'
	810	colormap = 'seismic'
	811
	812	def setup(self):
	813	self.ncols = 1
	814	self.nrows = self.dataOut.data_output.shape[0]
	815	self.width = 10
	816	self.height = 2.2*self.nrows
	817	self.ylabel = 'Height [Km]'
	818	self.titles = ['Zonal Wind' ,'Meridional Wind', 'Vertical Wind']
	819	self.clabels = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
	820	self.windFactor = [1, 1, 100]
	821
	822	if self.figure is None:
	823	self.figure = plt.figure(figsize=(self.width, self.height),
	824	edgecolor='k',
	825	facecolor='w')
	826	else:
	827	self.figure.clf()
	828	self.axes = []
	829
	830	for n in range(self.nrows):
	831	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	832	ax.firsttime = True
	833	self.axes.append(ax)
	834
	835	def plot(self):
	836
	837	self.x = np.array(self.times)
	838	self.y = self.dataOut.heightList
	839	self.z = []
	840
	841	for ch in range(self.nrows):
	842	self.z.append([self.data['output'][t][ch] for t in self.times])
	843
	844	self.z = np.array(self.z)
	845	self.z = numpy.ma.masked_invalid(self.z)
	846
	847	cmap=plt.get_cmap(self.colormap)
	848	cmap.set_bad('black', 1.)
	849
	850	for n, ax in enumerate(self.axes):
	851	x, y, z = self.fill_gaps(*self.decimate())
	852	xmin = self.min_time
	853	xmax = xmin+self.xrange6060
	854	if ax.firsttime:
	855	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	856	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	857	self.zmax = self.zmax if self.zmax else numpy.nanmax(abs(self.z[:-1, :]))
	858	self.zmin = self.zmin if self.zmin else -self.zmax
	859
	860	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
	861	vmin=self.zmin,
	862	vmax=self.zmax,
	863	cmap=cmap
	864	)
	865	divider = make_axes_locatable(ax)
	866	cax = divider.new_horizontal(size='2%', pad=0.05)
	867	self.figure.add_axes(cax)
	868	cb = plt.colorbar(plot, cax)
	869	cb.set_label(self.clabels[n])
	870	ax.set_ylim(self.ymin, self.ymax)
	871
	872	ax.xaxis.set_major_formatter(FuncFormatter(func))
	873	ax.xaxis.set_major_locator(LinearLocator(6))
	874
	875	ax.set_ylabel(self.ylabel)
	876
	877	ax.set_xlim(xmin, xmax)
	878	ax.firsttime = False
	879	else:
	880	ax.collections.remove(ax.collections[0])
	881	ax.set_xlim(xmin, xmax)
	882	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
	883	vmin=self.zmin,
	884	vmax=self.zmax,
	885	cmap=plt.get_cmap(self.colormap)
	886	)
	887	ax.set_title('{} {}'.format(self.titles[n],
	888	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	889	size=8)
	890
	891	self.saveTime = self.min_time
	892
	893
	894	class PlotSNRData(PlotRTIData):	636	class PlotSNRData(PlotRTIData):
			637	'''
			638	Plot for SNR Data
			639	'''
			640
	895	CODE = 'snr'	641	CODE = 'snr'
	896	colormap = 'jet'	642	colormap = 'jet'
	897		643
			644
	898	class PlotDOPData(PlotRTIData):	645	class PlotDOPData(PlotRTIData):
			646	'''
			647	Plot for DOPPLER Data
			648	'''
			649
	899	CODE = 'dop'	650	CODE = 'dop'
	900	colormap = 'jet'	651	colormap = 'jet'
	901		652
	902		653
	903	class PlotPHASEData(PlotCOHData):
	904	CODE = 'phase'
	905	colormap = 'seismic'
	906
	907
	908	class PlotSkyMapData(PlotData):	654	class PlotSkyMapData(PlotData):
			655	'''
			656	Plot for meteors detection data
			657	'''
	909		658
	910	CODE = 'met'	659	CODE = 'met'
	911		660
	912	def setup(self):	661	def setup(self):
	913		662
	914	self.ncols = 1	663	self.ncols = 1
	915	self.nrows = 1	664	self.nrows = 1
	916	self.width = 7.2	665	self.width = 7.2
	917	self.height = 7.2	666	self.height = 7.2
	918		667
	919	self.xlabel = 'Zonal Zenith Angle (deg)'	668	self.xlabel = 'Zonal Zenith Angle (deg)'
	920	self.ylabel = 'Meridional Zenith Angle (deg)'	669	self.ylabel = 'Meridional Zenith Angle (deg)'
	921		670
	922	if self.figure is None:	671	if self.figure is None:
	923	self.figure = plt.figure(figsize=(self.width, self.height),	672	self.figure = plt.figure(figsize=(self.width, self.height),
	924	edgecolor='k',	673	edgecolor='k',
	925	facecolor='w')	674	facecolor='w')
	926	else:	675	else:
	927	self.figure.clf()	676	self.figure.clf()
	928		677
	929	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)	678	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
	930	self.ax.firsttime = True	679	self.ax.firsttime = True
	931		680
	932		681
	933	def plot(self):	682	def plot(self):
	934		683
	935	arrayParameters = np.concatenate([self.data['param'][t] for t in self.times])	684	arrayParameters = numpy.concatenate([self.data['param'][t] for t in self.data.times])
	936	error = arrayParameters[:,-1]	685	error = arrayParameters[:,-1]
	937	indValid = numpy.where(error == 0)[0]	686	indValid = numpy.where(error == 0)[0]
	938	finalMeteor = arrayParameters[indValid,:]	687	finalMeteor = arrayParameters[indValid,:]
	939	finalAzimuth = finalMeteor[:,3]	688	finalAzimuth = finalMeteor[:,3]
	940	finalZenith = finalMeteor[:,4]	689	finalZenith = finalMeteor[:,4]
	941		690
	942	x = finalAzimuth*numpy.pi/180	691	x = finalAzimuth*numpy.pi/180
	943	y = finalZenith	692	y = finalZenith
	944		693
	945	if self.ax.firsttime:	694	if self.ax.firsttime:
	946	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]	695	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
	947	self.ax.set_ylim(0,90)	696	self.ax.set_ylim(0,90)
	948	self.ax.set_yticks(numpy.arange(0,90,20))	697	self.ax.set_yticks(numpy.arange(0,90,20))
	949	self.ax.set_xlabel(self.xlabel)	698	self.ax.set_xlabel(self.xlabel)
	950	self.ax.set_ylabel(self.ylabel)	699	self.ax.set_ylabel(self.ylabel)
	951	self.ax.yaxis.labelpad = 40	700	self.ax.yaxis.labelpad = 40
	952	self.ax.firsttime = False	701	self.ax.firsttime = False
	953	else:	702	else:
	954	self.ax.plot.set_data(x, y)	703	self.ax.plot.set_data(x, y)
	955		704
	956		705
	957	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')	706	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')
	958	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')	707	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')
	959	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,	708	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
	960	dt2,	709	dt2,
	961	len(x))	710	len(x))
	962	self.ax.set_title(title, size=8)	711	self.ax.set_title(title, size=8)
	963		712
	964	self.saveTime = self.max_time	713	self.saveTime = self.max_time
			714
			715	class PlotParamData(PlotRTIData):
			716	'''
			717	Plot for data_param object
			718	'''
			719
			720	CODE = 'param'
			721	colormap = 'seismic'
			722
			723	def setup(self):
			724	self.xaxis = 'time'
			725	self.ncols = 1
			726	self.nrows = self.data.shape(self.CODE)[0]
			727	self.nplots = self.nrows
			728	if self.showSNR:
			729	self.nrows += 1
			730
			731	self.ylabel = 'Height [Km]'
			732	self.titles = self.data.parameters \
			733	if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
			734	if self.showSNR:
			735	self.titles.append('SNR')
			736
			737	def plot(self):
			738	self.data.normalize_heights()
			739	self.x = self.data.times
			740	self.y = self.data.heights
			741	if self.showSNR:
			742	self.z = numpy.concatenate(
			743	(self.data[self.CODE], self.data['snr'])
			744	)
			745	else:
			746	self.z = self.data[self.CODE]
			747
			748	self.z = numpy.ma.masked_invalid(self.z)
			749
			750	for n, ax in enumerate(self.axes):
			751
			752	x, y, z = self.fill_gaps(*self.decimate())
			753
			754	if ax.firsttime:
			755	if self.zlimits is not None:
			756	self.zmin, self.zmax = self.zlimits[n]
			757	self.zmax = self.zmax if self.zmax is not None else numpy.nanmax(abs(self.z[:-1, :]))
			758	self.zmin = self.zmin if self.zmin is not None else -self.zmax
			759	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			760	vmin=self.zmin,
			761	vmax=self.zmax,
			762	cmap=self.cmaps[n]
			763	)
			764	else:
			765	if self.zlimits is not None:
			766	self.zmin, self.zmax = self.zlimits[n]
			767	ax.collections.remove(ax.collections[0])
			768	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			769	vmin=self.zmin,
			770	vmax=self.zmax,
			771	cmap=self.cmaps[n]
			772	)
			773
			774	self.saveTime = self.min_time
			775
			776	class PlotOuputData(PlotParamData):
			777	'''
			778	Plot data_output object
			779	'''
			780
			781	CODE = 'output'
			782	colormap = 'seismic' No newline at end of file

schainpy/model/proc/jroproc_parameters.py +1950 -710

             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')
-            class ParametersProc(ProcessingUnit):
+            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
+                    # 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)
                         self.dataOut.data_spc = self.dataIn.data_spc
                         self.dataOut.data_cspc = self.dataIn.data_cspc
                         self.dataOut.nProfiles = self.dataIn.nProfiles
                         self.dataOut.nIncohInt = self.dataIn.nIncohInt
                         self.dataOut.nFFTPoints = self.dataIn.nFFTPoints
                         self.dataOut.ippFactor = self.dataIn.ippFactor
-                        #self.dataOut.normFactor = self.dataIn.getNormFactor()
-                        self.dataOut.pairsList = self.dataIn.pairsList
-                        self.dataOut.groupList = self.dataIn.pairsList
                         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.pairsList = self.dataIn.pairsList
+                        self.dataOut.groupList = self.dataIn.pairsList
                         self.dataOut.flagNoData = False
+                        if hasattr(self.dataIn, 'ChanDist'): #Distances of receiver channels
+                            self.dataOut.ChanDist = self.dataIn.ChanDist
+                        else: self.dataOut.ChanDist = None
+                        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.utctimeInit = self.dataIn.utctime
                         self.dataOut.flagNoData = False
                         return True
                     self.__updateObjFromInput()
                     self.dataOut.utctimeInit = self.dataIn.utctime
                     self.dataOut.paramInterval = self.dataIn.timeInterval
                     return
-            class SpectralMoments(Operation):
+            def target(tups):
+                obj, args = tups
+                #print 'TARGETTT', obj, args
+                return obj.FitGau(args)
+            class GaussianFit(Operation):
                 '''
-                    Function SpectralMoments()
+                    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
-                    Calculates moments (power, mean, standard deviation) and SNR of the signal
+                    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.
-                    Type of dataIn:    Spectra
+                    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.)
-                    Configuration Parameters:
+            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
+                    Gt:     Transmission Gain                dB
+                    Gr:     Reception Gain                   dB
+                    Lambda: Wavelenght                       m
+                    aL:      Attenuation loses               dB
+                    tauW:   Width of transmission pulse      s
+                    ThetaT: Transmission antenna bean angle  rad
+                    ThetaR: Reception antenna beam angle     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
+                    #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=[]
+                    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)
+                        if abs(Vzon)<100. and abs(Vzon)> 0.:
+                            velocityX=numpy.append(velocityX, Vzon)#Vmag
+                        else:
+                            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
+                            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 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])
+                    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 'noise',noise
+                    print 'zline',zline.shape, zline[0:20]
+                    print 'FactNorm',FactNorm.shape, FactNorm[0:20]
+                    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 'CSPCFactor', CSPCFactor#, CSPCFactor[0:20]
+                    print numpy.sum(ySamples[chan_index0]), numpy.sum(ySamples[chan_index1]), -noise[i]
+                    print 'CSPCNorm', CSPCNorm.shape, CSPCNorm[0:20]
+                    print 'CSPCNorm suma', numpy.sum(CSPCNorm)
+                    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 'len(xSamples): ',len(xSamples)
+                    print 'yMean: ', yMean.shape, yMean[0:20]
+                    print 'ySamples', ySamples.shape, ySamples[0,0:20]
+                    print 'xSamples: ',xSamples.shape, xSamples[0:20]
+                    print 'meanGauss',meanGauss
+                    print 'sigma',sigma
+                    #if (abs(meanGauss/sigma**2) > 0.0001) : #0.000000001):
+                    if dbSNR > SNRlimit :
+                        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 'GCpos',GCpos, ( len(xFrec)- len(xFrec)*0.1)
+                    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 'vzon y vmer', Vzon, Vmer
+                    return Vzon, Vmer, Vver, GaussCenter
+            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])
+                        data_param[ind,:,:] = self.__calculateMoments( data[ind,:,:] , absc , noise[ind] )
                     dataOut.data_param = data_param[:,1:,:]
                     dataOut.data_SNR = data_param[:,0]
                     dataOut.data_DOP = data_param[:,1]
                     dataOut.data_MEAN = data_param[:,2]
                     dataOut.data_STD = data_param[:,3]
                     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):
+                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 is None): nicoh = 1
-                    if (graph is None): graph = 0
+                    if (nicoh == None): nicoh = 1
-                    if (smooth is None): smooth = 0
+                    if (graph == None): graph = 0
+                    if (smooth == None): smooth = 0
                     elif (self.smooth < 3): smooth = 0
-                    if (type1 is None): type1 = 0
+                    if (type1 == None): type1 = 0
-                    if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
+                    if (fwindow == None): fwindow = numpy.zeros(oldfreq.size) + 1
-                    if (snrth is None): snrth = -3
+                    if (snrth == None): snrth = -3
-                    if (dc is None): dc = 0
+                    if (dc == None): dc = 0
-                    if (aliasing is None): aliasing = 0
+                    if (aliasing == None): aliasing = 0
-                    if (oldfd is None): oldfd = 0
+                    if (oldfd == None): oldfd = 0
-                    if (wwauto is None): wwauto = 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[0]
+                    spectra = self.dataOut.data_pre
-                    cspectra = self.dataOut.data_pre[1]
+                    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 is None:
+                            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, binkm=2):
+                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)/binkm
+                    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']
                     azimuth = kwargs['azimuth']
                     theta_x = numpy.array(kwargs['theta_x'])
                     theta_y = numpy.array(kwargs['theta_y'])
                     utctime = metArray[:,0]
                     cmet = metArray[:,1].astype(int)
                     hmet = metArray[:,3].astype(int)
                     SNRmet = metArray[:,4]
                     vmet = metArray[:,5]
                     spcmet = metArray[:,6]
                     nChan = numpy.max(cmet) + 1
                     nHeights = len(heightList)
                     azimuth_arr, zenith_arr, dir_cosu, dir_cosv, dir_cosw = self.__calculateAngles(theta_x, theta_y, azimuth)
                     hmet = heightList[hmet]
                     h1met = hmet*numpy.cos(zenith_arr[cmet])      #Corrected heights
                     velEst = numpy.zeros((heightList.size,2))*numpy.nan
                     for i in range(nHeights - 1):
                         hmin = heightList[i]
                         hmax = heightList[i + 1]
                         thisH = (h1met>=hmin) & (h1met<hmax) & (cmet!=2) & (SNRmet>8) & (vmet<50) & (spcmet<10)
                         indthisH = numpy.where(thisH)
                         if numpy.size(indthisH) > 3:
                             vel_aux = vmet[thisH]
                             chan_aux = cmet[thisH]
                             cosu_aux = dir_cosu[chan_aux]
                             cosv_aux = dir_cosv[chan_aux]
                             cosw_aux = dir_cosw[chan_aux]
                             nch = numpy.size(numpy.unique(chan_aux))
                             if  nch > 1:
                                 A = self.__calculateMatA(cosu_aux, cosv_aux, cosw_aux, True)
                                 velEst[i,:] = numpy.dot(A,vel_aux)
                     return velEst
                 def run(self, dataOut, technique, nHours=1, hmin=70, hmax=110, **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
-                        if kwargs.has_key('BinKm'):
-                            binkm = kwargs['BinKm']
-                        else:
-                            binkm = 2
                         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 is None:
+                        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, binkm)
+                            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.06
                         if kwargs.has_key('dfactor'):
                             dfactor = kwargs['dfactor']
                         if kwargs.has_key('mode'):
                             mode = kwargs['mode']
                         if kwargs.has_key('theta_x'):
                             theta_x = kwargs['theta_x']
                         if kwargs.has_key('theta_y'):
                             theta_y = kwargs['theta_y']
                         else: mode = 'SA'
                         #Borrar luego esto
-                        if dataOut.groupList is None:
+                        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 is None:
+                        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, azimuth=azimuth, theta_x=theta_x, theta_y=theta_y)
                             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, dataOut, mode, SNRthresh=8, phaseDerThresh=0.5, cohThresh=0.8, allData = False):
                     data_acf = dataOut.data_pre[0]
                     data_ccf = dataOut.data_pre[1]
                     pairsList = dataOut.groupList[1]
                     lamb = dataOut.C/dataOut.frequency
                     tSamp = dataOut.ippSeconds*dataOut.nCohInt
                     paramInterval = dataOut.paramInterval
                     nChannels = data_acf.shape[0]
                     nLags = data_acf.shape[1]
                     nProfiles = data_acf.shape[2]
                     nHeights = dataOut.nHeights
                     nCohInt = dataOut.nCohInt
                     sec = numpy.round(nProfiles/dataOut.paramInterval)
                     heightList = dataOut.heightList
                     ippSeconds = dataOut.ippSeconds*dataOut.nCohInt*dataOut.nAvg
                     utctime = dataOut.utctime
                     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':
                         dataOut.groupList = dataOut.groupList[1]
                         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 = pairsList[p][0]
                             ch1 = pairsList[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':
                         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))
                         acf1 = data_acf[:,1,:,:]
                         acf2 = data_acf[:,2,:,:]
                         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) < 20
                             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:
                         dataOut.flagNoData = True
                     else:
                         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 is None:
+                    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 is None:
+                        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] if isinstance(indUPthresh[j], (int, float)) else indUPthresh[j][0] ##CHECK!!!!
+                                    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,4))
+                    pairslist1.append((0,1))
-                    pairslist1.append((1,3))
+                    pairslist1.append((3,4))
                     listMeteors1 = []
                     listPowerSeries = []
                     listVoltageSeries = []
                     #volts has the war data
-                    if frequency == 30.175e6:
+                    if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
-                    lag = int(numpy.ceil(timeLag/timeInterval))
+                    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 = int(listMeteors[i][0])
+                        mHeight = listMeteors[i][0]
-                        mStart = int(listMeteors[i][1])
+                        mStart = listMeteors[i][1]
-                        mPeak = int(listMeteors[i][2])
+                        mPeak = listMeteors[i][2]
-                        mEnd = int(listMeteors[i][3])
+                        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 == 30.175e6:
+                    if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
-                    lag = int(numpy.ceil(timeLag/timeInterval))
+                    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,4))
+                    pairslist1.append((0,1))
-                    pairslist1.append((1,3))
+                    pairslist1.append((3,4))
                     numPairs = len(pairslist1)
                     #Time Lag
                     timeLag = 45*10**-3
                     c = 3e8
                     lag = numpy.ceil(timeLag/timeInterval)
-                    freq = 30.175e6
+                    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,4,2,3],0])
+                            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 is None:
+                    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[0]]
                         d3 = d[pairi[0]]
                         phip2 = phases[:,pairi[1]]
                         d2 = d[pairi[1]]
                         #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
                         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] #x es 0
                     pairy = pairsList[1] #y es 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
                     nstepsy = 20
                     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)):
                                 d3 = d[pairsList[1][0]]
                                 d2 = d[pairsList[1][1]]
                                 d5 = d[pairsList[0][0]]
                                 d4 = d[pairsList[0][1]]
                                 alp2 = alpha_y[iy]  #gamma 1
                                 alp4 = alpha_x[ix]  #gamma 0
                                 alp3 = -alp2*d3/d2 - gammas[1]
                                 alp5 = -alp4*d5/d4 - gammas[0]
             #                     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[pairsList[0][1]] = alp4
                                 jph[pairsList[0][0]] = alp5
                                 jph[pairsList[1][0]] = alp3
                                 jph[pairsList[1][1]] = alp2
                                 jph_array[:,ix,iy] = jph
             #                     d = [2.0,2.5,2.5,2.0]
                                 #falta chequear si va a leer bien  los meteoros
                                 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 is None:
+                    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)) #Estrella
             #             pairs = ((1,0),(2,3)) #T
                         if channelPositions is 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)
                         #Checking correct order of pairs
                         pairs = []
                         if distances[1] > distances[0]:
                             pairs.append((1,0))
                         else:
                             pairs.append((0,1))
                         if distances[3] > distances[2]:
                             pairs.append((3,2))
                         else:
                             pairs.append((2,3))
             #             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
-                        dataOut.channelList = pairslist0
                         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][:len(ind_h)]
                     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_spectra.py +17 -18

+            import itertools
             import numpy
             from jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
             class SpectraProc(ProcessingUnit):
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                     self.id_min = None
                     self.id_max = None
                 def __updateSpecFromVoltage(self):
                     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.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.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.realtime = self.dataIn.realtime
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                     """
                     fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
                     fft_volt = fft_volt.astype(numpy.dtype('complex'))
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
                                 raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
                             if pair[1] not in self.dataOut.channelList:
                                 raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
                             cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc = spc
                     self.dataOut.data_cspc = cspc
                     self.dataOut.data_dc = dc
                     self.dataOut.blockSize = blocksize
                     self.dataOut.flagShiftFFT = True
                 def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None):
                     self.dataOut.flagNoData = True
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
-            #             self.__selectPairs(pairsList)
+                        if not pairsList:
+                            pairsList = itertools.combinations(self.dataOut.channelList, 2)
+                        if self.dataOut.data_cspc is not None:
+                            self.__selectPairs(pairsList)
                         return True
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProc.run() need nFFTPoints input variable"
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                         if ippFactor == None:
                             ippFactor = 1
                         self.dataOut.ippFactor = ippFactor
                         self.dataOut.nFFTPoints = nFFTPoints
                         self.dataOut.pairsList = pairsList
                         if self.buffer is None:
                             self.buffer = numpy.zeros( (self.dataIn.nChannels,
                                                         nProfiles,
                                                         self.dataIn.nHeights),
                                                       dtype='complex')
                         if self.dataIn.flagDataAsBlock:
                             #data dimension: [nChannels, nProfiles, nSamples]
                             nVoltProfiles = self.dataIn.data.shape[1]
             #                 nVoltProfiles = self.dataIn.nProfiles
                             if nVoltProfiles == nProfiles:
                                 self.buffer = self.dataIn.data.copy()
                                 self.profIndex = nVoltProfiles
                             elif nVoltProfiles < nProfiles:
                                 if self.profIndex == 0:
                                     self.id_min = 0
                                     self.id_max = nVoltProfiles
                                 self.buffer[:,self.id_min:self.id_max,:] = self.dataIn.data
                                 self.profIndex += nVoltProfiles
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
                                 raise ValueError, "The type object %s has %d profiles, it should just has %d profiles"%(self.dataIn.type,self.dataIn.data.shape[1],nProfiles)
                                 self.dataOut.flagNoData = True
                                 return 0
                         else:
                             self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
                             self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == nProfiles:
                             self.__updateSpecFromVoltage()
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
                         return True
                     raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
                 def __selectPairs(self, pairsList):
-                    if channelList == None:
+                    if not pairsList:
                         return
-                    pairsIndexListSelected = []
+                    pairs = []
+                    pairsIndex = []
-                    for thisPair in pairsList:
-                        if thisPair not in self.dataOut.pairsList:
+                    for pair in pairsList:
+                        if pair[0] not in self.dataOut.channelList or pair[1] not in self.dataOut.channelList:
                             continue
+                        pairs.append(pair)
-                        pairIndex = self.dataOut.pairsList.index(thisPair)
+                        pairsIndex.append(pairs.index(pair))
-                        pairsIndexListSelected.append(pairIndex)
+                    self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
+                    self.dataOut.pairsList = pairs
-                    if not pairsIndexListSelected:
+                    self.dataOut.pairsIndexList = pairsIndex
-                        self.dataOut.data_cspc = None
-                        self.dataOut.pairsList = []
-                        return
-                    self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
-                    self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
                     return
                 def __selectPairsByChannel(self, channelList=None):
                     if channelList == None:
                         return
                     pairsIndexListSelected = []
                     for pairIndex in self.dataOut.pairsIndexList:
                         #First pair
                         if self.dataOut.pairsList[pairIndex][0] not in channelList:
                             continue
                         #Second pair
                         if self.dataOut.pairsList[pairIndex][1] not in channelList:
                             continue
                         pairsIndexListSelected.append(pairIndex)
                     if not pairsIndexListSelected:
                         self.dataOut.data_cspc = None
                         self.dataOut.pairsList = []
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
                     self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
                     return
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
             #         nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     data_dc = self.dataOut.data_dc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
                     self.__selectPairsByChannel(self.dataOut.channelList)
                     return 1
                 def selectHeights(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minHei > maxHei):
                         raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def getBeaconSignal(self, tauindex = 0, channelindex = 0, hei_ref=None):
                     newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                     if hei_ref != None:
                         newheis = numpy.where(self.dataOut.heightList>hei_ref)
                     minIndex = min(newheis[0])
                     maxIndex = max(newheis[0])
                     data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
                     heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                     # determina indices
                     nheis = int(self.dataOut.radarControllerHeaderObj.txB/(self.dataOut.heightList[1]-self.dataOut.heightList[0]))
                     avg_dB = 10*numpy.log10(numpy.sum(data_spc[channelindex,:,:],axis=0))
                     beacon_dB = numpy.sort(avg_dB)[-nheis:]
                     beacon_heiIndexList = []
                     for val in avg_dB.tolist():
                         if val >= beacon_dB[0]:
                             beacon_heiIndexList.append(avg_dB.tolist().index(val))
                     #data_spc = data_spc[:,:,beacon_heiIndexList]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
                         #data_cspc = data_cspc[:,:,beacon_heiIndexList]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
                         #data_dc = data_dc[:,beacon_heiIndexList]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = heightList
                     self.dataOut.beacon_heiIndexList = beacon_heiIndexList
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     #Spectra
                     data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                     return 1
                 def removeDC(self, mode = 2):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     if jcspectra is not None:
                         jcspectraExist = True
                         num_pairs = jcspectra.shape[0]
                     else:   jcspectraExist = False
                     freq_dc = jspectra.shape[1]/2
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
                         ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                         if jcspectraExist:
                             jcspectra[:,freq_dc,:] = (jcspectra[:,ind_vel[1],:] + jcspectra[:,ind_vel[2],:])/2
                     if mode == 2:
                         vel = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
                             xx[fil,:] = vel[fil]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                         for ich in range(num_chan):
                             yy = jspectra[ich,ind_vel,:]
                             jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
                             junkid = jspectra[ich,freq_dc,:]<=0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
                         if jcspectraExist:
                             for ip in range(num_pairs):
                                 yy = jcspectra[ip,ind_vel,:]
                                 jcspectra[ip,freq_dc,:] = numpy.dot(xx_aux,yy)
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def removeInterference(self,  interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     jnoise = self.dataOut.getNoise()
                     num_incoh = self.dataOut.nIncohInt
                     num_channel  = jspectra.shape[0]
                     num_prof  = jspectra.shape[1]
                     num_hei   = jspectra.shape[2]
                     #hei_interf
                     if hei_interf is None:
                         count_hei = num_hei/2   #Como es entero no importa
                         hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     #nhei_interf
                     if (nhei_interf == None):
                         nhei_interf = 5
                     if (nhei_interf < 1):
                         nhei_interf = 1
                     if (nhei_interf > count_hei):
                         nhei_interf = count_hei
                     if (offhei_interf == None):
                         offhei_interf = 0
                     ind_hei = range(num_hei)
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
                     mask_prof = numpy.asarray(range(num_prof))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof/2]
                     #noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
                     if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
                         jnoise = numpy.nan
                     noise_exist = jnoise[0] < numpy.Inf
                     #Subrutina de Remocion de la Interferencia
                     for ich in range(num_channel):
                         #Se ordena los espectros segun su potencia (menor a mayor)
                         power = jspectra[ich,mask_prof,:]
                         power = power[:,hei_interf]
                         power = power.sum(axis = 0)
                         psort = power.ravel().argsort()
                         #Se estima la interferencia promedio en los Espectros de Potencia empleando
                         junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
                         if noise_exist:
                         #    tmp_noise = jnoise[ich] / num_prof
                             tmp_noise = jnoise[ich]
                         junkspc_interf = junkspc_interf - tmp_noise
                         #junkspc_interf[:,comp_mask_prof] = 0
                         jspc_interf = junkspc_interf.sum(axis = 0) / nhei_interf
                         jspc_interf = jspc_interf.transpose()
                         #Calculando el espectro de interferencia promedio
                         noiseid =  numpy.where(jspc_interf <= tmp_noise/ numpy.sqrt(num_incoh))
                         noiseid = noiseid[0]
                         cnoiseid = noiseid.size
                         interfid = numpy.where(jspc_interf > tmp_noise/ numpy.sqrt(num_incoh))
                         interfid = interfid[0]
                         cinterfid = interfid.size
                         if (cnoiseid > 0):   jspc_interf[noiseid] = 0
                         #Expandiendo los perfiles a limpiar
                         if (cinterfid > 0):
                             new_interfid = (numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof)%num_prof
                             new_interfid = numpy.asarray(new_interfid)
                             new_interfid = {x for x in new_interfid}
                             new_interfid = numpy.array(list(new_interfid))
                             new_cinterfid = new_interfid.size
                         else: new_cinterfid = 0
                         for ip in range(new_cinterfid):
                             ind = junkspc_interf[:,new_interfid[ip]].ravel().argsort()
                             jspc_interf[new_interfid[ip]] = junkspc_interf[ind[nhei_interf/2],new_interfid[ip]]
                         jspectra[ich,:,ind_hei] = jspectra[ich,:,ind_hei] - jspc_interf #Corregir indices
                         #Removiendo la interferencia del punto de mayor interferencia
                         ListAux = jspc_interf[mask_prof].tolist()
                         maxid = ListAux.index(max(ListAux))
                         if cinterfid > 0:
                             for ip in range(cinterfid*(interf == 2) - 1):
                                 ind = (jspectra[ich,interfid[ip],:] < tmp_noise*(1 + 1/numpy.sqrt(num_incoh))).nonzero()
                                 cind = len(ind)
                                 if (cind > 0):
                                     jspectra[ich,interfid[ip],ind] = tmp_noise*(1 + (numpy.random.uniform(cind) - 0.5)/numpy.sqrt(num_incoh))
                             ind = numpy.array([-2,-1,1,2])
                             xx = numpy.zeros([4,4])
                             for id1 in range(4):
                                 xx[:,id1] = ind[id1]**numpy.asarray(range(4))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:,0]
                             ind = (ind + maxid + num_mask_prof)%num_mask_prof
                             yy = jspectra[ich,mask_prof[ind],:]
                             jspectra[ich,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
                         indAux = (jspectra[ich,:,:] < tmp_noise*(1-1/numpy.sqrt(num_incoh))).nonzero()
                         jspectra[ich,indAux[0],indAux[1]] = tmp_noise * (1 - 1/numpy.sqrt(num_incoh))
                     #Remocion de Interferencia en el Cross Spectra
                     if jcspectra is None: return jspectra, jcspectra
                     num_pairs = jcspectra.size/(num_prof*num_hei)
                     jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
                     for ip in range(num_pairs):
                         #-------------------------------------------
                         cspower = numpy.abs(jcspectra[ip,mask_prof,:])
                         cspower = cspower[:,hei_interf]
                         cspower = cspower.sum(axis = 0)
                         cspsort = cspower.ravel().argsort()
                         junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis = 1)/nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
                         median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
                         median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
                         junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
                         for iprof in range(num_prof):
                             ind = numpy.abs(junkcspc_interf[iprof,:]).ravel().argsort()
                             jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf/2]]
                         #Removiendo la Interferencia
                         jcspectra[ip,:,ind_hei] = jcspectra[ip,:,ind_hei] - jcspc_interf
                         ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
                         maxid = ListAux.index(max(ListAux))
                         ind = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for id1 in range(4):
                             xx[:,id1] = ind[id1]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:,0]
                         ind = (ind + maxid + num_mask_prof)%num_mask_prof
                         yy = jcspectra[ip,mask_prof[ind],:]
                         jcspectra[ip,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
                     #Guardar Resultados
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def setRadarFrequency(self, frequency=None):
                     if frequency != None:
                         self.dataOut.frequency = frequency
                     return 1
                 def getNoise(self, minHei=None, maxHei=None, minVel=None, maxVel=None):
                     #validacion de rango
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                     if maxHei == None:
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                         print 'minHei: %.2f is out of the heights range'%(minHei)
                         print 'minHei is setting to %.2f'%(self.dataOut.heightList[0])
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
                         print 'maxHei: %.2f is out of the heights range'%(maxHei)
                         print 'maxHei is setting to %.2f'%(self.dataOut.heightList[-1])
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                     velrange = self.dataOut.getVelRange(1)
                     if minVel == None:
                         minVel = velrange[0]
                     if maxVel == None:
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
                         print 'minVel: %.2f is out of the velocity range'%(minVel)
                         print 'minVel is setting to %.2f'%(velrange[0])
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
                         print 'maxVel: %.2f is out of the velocity range'%(maxVel)
                         print 'maxVel is setting to %.2f'%(velrange[-1])
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     # seleccion de indices para velocidades
                     indminvel = numpy.where(velrange >= minVel)
                     indmaxvel = numpy.where(velrange <= maxVel)
                     try:
                         minIndexVel = indminvel[0][0]
                     except:
                         minIndexVel = 0
                     try:
                         maxIndexVel = indmaxvel[0][-1]
                     except:
                         maxIndexVel = len(velrange)
                     #seleccion del espectro
                     data_spc = self.dataOut.data_spc[:,minIndexVel:maxIndexVel+1,minIndex:maxIndex+1]
                     #estimacion de ruido
                     noise = numpy.zeros(self.dataOut.nChannels)
                     for channel in range(self.dataOut.nChannels):
                         daux = data_spc[channel,:,:]
                         noise[channel] = hildebrand_sekhon(daux, self.dataOut.nIncohInt)
                     self.dataOut.noise_estimation = noise.copy()
                     return 1
             class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer_spc = None
                 __buffer_cspc = None
                 __buffer_dc = None
                 __dataReady = False
                 __timeInterval = None
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
             #         self.isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     self.__dataReady = False
                     self.__byTime = False
                     if n is None and timeInterval is None:
                         raise ValueError, "n or timeInterval should be specified ..."
                     if n is not None:
                         self.n = int(n)
                     else:
                         self.__integrationtime = int(timeInterval) #if (type(timeInterval)!=integer) -> change this line
                         self.n = None
                         self.__byTime = True
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                     """
                     self.__buffer_spc += data_spc
                     if data_cspc is None:
                         self.__buffer_cspc = None
                     else:
                         self.__buffer_cspc += data_cspc
                     if data_dc is None:
                         self.__buffer_dc = None
                     else:
                         self.__buffer_dc += data_dc
                     self.__profIndex += 1
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     data_spc = self.__buffer_spc
                     data_cspc = self.__buffer_cspc
                     data_dc = self.__buffer_dc
                     n = self.__profIndex
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if self.__profIndex == self.n:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def byTime(self, datatime, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def integrate(self, datatime, *args):
                     if self.__profIndex == 0:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                     if not self.__dataReady:
                         return None, None, None, None
                     return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if n==1:
                         return
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.isConfig = True
                     avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                         dataOut.data_spc,
                                                                                         dataOut.data_cspc,
                                                                                         dataOut.data_dc)
                     if self.__dataReady:
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False

schainpy/model/utils/jroutils_publish.py +209 -106

             '''
             @author: Juan C. Espinoza
             '''
             import time
             import json
             import numpy
             import paho.mqtt.client as mqtt
             import zmq
             import datetime
             from zmq.utils.monitor import recv_monitor_message
             from functools import wraps
             from threading import Thread
             from multiprocessing import Process
             from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
             from schainpy.model.data.jrodata import JROData
+            from schainpy.utils import log
             MAXNUMX = 100
             MAXNUMY = 100
             class PrettyFloat(float):
                 def __repr__(self):
                     return '%.2f' % self
             def roundFloats(obj):
                 if isinstance(obj, list):
                     return map(roundFloats, obj)
                 elif isinstance(obj, float):
                     return round(obj, 2)
             def decimate(z, MAXNUMY):
-                # dx = int(len(self.x)/self.__MAXNUMX) + 1
                 dy = int(len(z[0])/MAXNUMY) + 1
                 return z[::, ::dy]
             class throttle(object):
-                """Decorator that prevents a function from being called more than once every
+                '''
+                Decorator that prevents a function from being called more than once every
                 time period.
                 To create a function that cannot be called more than once a minute, but
                 will sleep until it can be called:
                 @throttle(minutes=1)
                 def foo():
                   pass
                 for i in range(10):
                   foo()
                   print "This function has run %s times." % i
-                """
+                '''
                 def __init__(self, seconds=0, minutes=0, hours=0):
                     self.throttle_period = datetime.timedelta(
                         seconds=seconds, minutes=minutes, hours=hours
                     )
                     self.time_of_last_call = datetime.datetime.min
                 def __call__(self, fn):
                     @wraps(fn)
                     def wrapper(*args, **kwargs):
                         now = datetime.datetime.now()
                         time_since_last_call = now - self.time_of_last_call
                         time_left = self.throttle_period - time_since_last_call
                         if time_left > datetime.timedelta(seconds=0):
                             return
                         self.time_of_last_call = datetime.datetime.now()
                         return fn(*args, **kwargs)
                     return wrapper
+            class Data(object):
+                '''
+                Object to hold data to be plotted
+                '''
+                def __init__(self, plottypes, throttle_value):
+                    self.plottypes = plottypes
+                    self.throttle = throttle_value
+                    self.ended = False
+                    self.__times = []
+                def __str__(self):
+                    dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
+                    return 'Data[{}][{}]'.format(';'.join(dum), len(self.__times))
+                def __len__(self):
+                    return len(self.__times)
+                def __getitem__(self, key):
+                    if key not in self.data:
+                        raise KeyError(log.error('Missing key: {}'.format(key)))
+                    if 'spc' in key:
+                        ret = self.data[key]
+                    else:
+                        ret = numpy.array([self.data[key][x] for x in self.times])
+                        if ret.ndim > 1:
+                            ret = numpy.swapaxes(ret, 0, 1)
+                    return ret
+                def setup(self):
+                    '''
+                    Configure object
+                    '''
+                    self.ended = False
+                    self.data = {}
+                    self.__times = []
+                    self.__heights = []
+                    self.__all_heights = set()
+                    for plot in self.plottypes:
+                        self.data[plot] = {}
+                def shape(self, key):
+                    '''
+                    Get the shape of the one-element data for the given key
+                    '''
+                    if len(self.data[key]):
+                        if 'spc' in key:
+                            return self.data[key].shape
+                        return self.data[key][self.__times[0]].shape
+                    return (0,)
+                def update(self, dataOut):
+                    '''
+                    Update data object with new dataOut
+                    '''
+                    tm = dataOut.utctime
+                    if tm in self.__times:
+                        return
+                    self.parameters = getattr(dataOut, 'parameters', [])
+                    self.pairs = dataOut.pairsList
+                    self.channels = dataOut.channelList
+                    self.xrange = (dataOut.getFreqRange(1)/1000. , dataOut.getAcfRange(1) , dataOut.getVelRange(1))
+                    self.interval = dataOut.getTimeInterval()
+                    self.__heights.append(dataOut.heightList)
+                    self.__all_heights.update(dataOut.heightList)
+                    self.__times.append(tm)
+                    for plot in self.plottypes:
+                        if plot == 'spc':
+                            z = dataOut.data_spc/dataOut.normFactor
+                            self.data[plot] = 10*numpy.log10(z)
+                        if plot == 'cspc':
+                            self.data[plot] = dataOut.data_cspc
+                        if plot == 'noise':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                        if plot == 'rti':
+                            self.data[plot][tm] = dataOut.getPower()
+                        if plot == 'snr_db':
+                            self.data['snr'][tm] = dataOut.data_SNR
+                        if plot == 'snr':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.data_SNR)
+                        if plot == 'dop':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.data_DOP)
+                        if plot == 'mean':
+                            self.data[plot][tm] = dataOut.data_MEAN
+                        if plot == 'std':
+                            self.data[plot][tm] = dataOut.data_STD
+                        if plot == 'coh':
+                            self.data[plot][tm] = dataOut.getCoherence()
+                        if plot == 'phase':
+                            self.data[plot][tm] = dataOut.getCoherence(phase=True)
+                        if plot == 'output':
+                            self.data[plot][tm] = dataOut.data_output
+                        if plot == 'param':
+                            self.data[plot][tm] = dataOut.data_param
+                def normalize_heights(self):
+                    '''
+                    Ensure same-dimension of the data for different heighList
+                    '''
+                    H = numpy.array(list(self.__all_heights))
+                    H.sort()
+                    for key in self.data:
+                        shape = self.shape(key)[:-1] + H.shape
+                        for tm, obj in self.data[key].items():
+                            h = self.__heights[self.__times.index(tm)]
+                            if H.size == h.size:
+                                continue
+                            index = numpy.where(numpy.in1d(H, h))[0]
+                            dummy = numpy.zeros(shape) + numpy.nan
+                            if len(shape) == 2:
+                                dummy[:, index] = obj
+                            else:
+                                dummy[index] = obj
+                            self.data[key][tm] = dummy
+                    self.__heights = [H for tm in self.__times]
+                def jsonify(self, decimate=False):
+                    '''
+                    Convert data to json
+                    '''
+                    ret = {}
+                    tm = self.times[-1]
+                    for key, value in self.data:
+                        if key in ('spc', 'cspc'):
+                            ret[key] = roundFloats(self.data[key].to_list())
+                        else:
+                            ret[key] = roundFloats(self.data[key][tm].to_list())
+                    ret['timestamp'] = tm
+                    ret['interval'] = self.interval
+                @property
+                def times(self):
+                    '''
+                    Return the list of times of the current data
+                    '''
+                    ret = numpy.array(self.__times)
+                    ret.sort()
+                    return ret
+                @property
+                def heights(self):
+                    '''
+                    Return the list of heights of the current data
+                    '''
+                    return numpy.array(self.__heights[-1])
             class PublishData(Operation):
-                """Clase publish."""
+                '''
+                Operation to send data over zmq.
+                '''
                 def __init__(self, **kwargs):
                     """Inicio."""
                     Operation.__init__(self, **kwargs)
                     self.isConfig = False
                     self.client = None
                     self.zeromq = None
                     self.mqtt = None
                 def on_disconnect(self, client, userdata, rc):
                     if rc != 0:
-                        print("Unexpected disconnection.")
+                        log.warning('Unexpected disconnection.')
                     self.connect()
                 def connect(self):
-                    print 'trying to connect'
+                    log.warning('trying to connect')
                     try:
                         self.client.connect(
                             host=self.host,
                             port=self.port,
                             keepalive=60*10,
                             bind_address='')
                         self.client.loop_start()
                         # self.client.publish(
                         #     self.topic + 'SETUP',
                         #     json.dumps(setup),
                         #     retain=True
                         #     )
                     except:
-                        print "MQTT Conection error."
+                        log.error('MQTT Conection error.')
                         self.client = False
                 def setup(self, port=1883, username=None, password=None, clientId="user", zeromq=1, verbose=True, **kwargs):
                     self.counter = 0
                     self.topic = kwargs.get('topic', 'schain')
                     self.delay = kwargs.get('delay', 0)
                     self.plottype = kwargs.get('plottype', 'spectra')
                     self.host = kwargs.get('host', "10.10.10.82")
                     self.port = kwargs.get('port', 3000)
                     self.clientId = clientId
                     self.cnt = 0
                     self.zeromq = zeromq
                     self.mqtt = kwargs.get('plottype', 0)
                     self.client = None
                     self.verbose = verbose
-                    self.dataOut.firstdata = True
                     setup = []
                     if mqtt is 1:
                         self.client = mqtt.Client(
                             client_id=self.clientId + self.topic + 'SCHAIN',
                             clean_session=True)
                         self.client.on_disconnect = self.on_disconnect
                         self.connect()
                         for plot in self.plottype:
                             setup.append({
                                 'plot': plot,
                                 'topic': self.topic + plot,
                                 'title': getattr(self, plot + '_' + 'title', False),
                                 'xlabel': getattr(self, plot + '_' + 'xlabel', False),
                                 'ylabel': getattr(self, plot + '_' + 'ylabel', False),
                                 'xrange': getattr(self, plot + '_' + 'xrange', False),
                                 'yrange': getattr(self, plot + '_' + 'yrange', False),
                                 'zrange': getattr(self, plot + '_' + 'zrange', False),
                             })
                     if zeromq is 1:
                         context = zmq.Context()
                         self.zmq_socket = context.socket(zmq.PUSH)
                         server = kwargs.get('server', 'zmq.pipe')
                         if 'tcp://' in server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % server
                         self.zmq_socket.connect(address)
                         time.sleep(1)
                 def publish_data(self):
                     self.dataOut.finished = False
                     if self.mqtt is 1:
                         yData = self.dataOut.heightList[:2].tolist()
                         if self.plottype == 'spectra':
                             data = getattr(self.dataOut, 'data_spc')
                             z = data/self.dataOut.normFactor
                             zdB = 10*numpy.log10(z)
                             xlen, ylen = zdB[0].shape
                             dx = int(xlen/MAXNUMX) + 1
                             dy = int(ylen/MAXNUMY) + 1
                             Z = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 Z[i] = zdB[i][::dx, ::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(Z),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
-                            # print payload
                         elif self.plottype in ('rti', 'power'):
                             data = getattr(self.dataOut, 'data_spc')
                             z = data/self.dataOut.normFactor
                             avg = numpy.average(z, axis=1)
                             avgdB = 10*numpy.log10(avg)
                             xlen, ylen = z[0].shape
                             dy = numpy.floor(ylen/self.__MAXNUMY) + 1
                             AVG = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 AVG[i] = avgdB[i][::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(AVG),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         elif self.plottype == 'noise':
                             noise = self.dataOut.getNoise()/self.dataOut.normFactor
                             noisedB = 10*numpy.log10(noise)
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(noisedB.reshape(-1, 1).tolist()),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         elif self.plottype == 'snr':
                             data = getattr(self.dataOut, 'data_SNR')
                             avgdB = 10*numpy.log10(data)
                             ylen = data[0].size
                             dy = numpy.floor(ylen/self.__MAXNUMY) + 1
                             AVG = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 AVG[i] = avgdB[i][::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(AVG),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         else:
                             print "Tipo de grafico invalido"
                             payload = {
                                 'data': 'None',
                                 'timestamp': 'None',
                                 'type': None
                             }
-                            # print 'Publishing data to {}'.format(self.host)
                         self.client.publish(self.topic + self.plottype, json.dumps(payload), qos=0)
                     if self.zeromq is 1:
                         if self.verbose:
-                            print '[Sending] {} - {}'.format(self.dataOut.type, self.dataOut.datatime)
+                            log.log(
+                                '{} - {}'.format(self.dataOut.type, self.dataOut.datatime),
+                                'Sending'
+                            )
                         self.zmq_socket.send_pyobj(self.dataOut)
-                        self.dataOut.firstdata = False
                 def run(self, dataOut, **kwargs):
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.publish_data()
                     time.sleep(self.delay)
                 def close(self):
                     if self.zeromq is 1:
                         self.dataOut.finished = True
                         self.zmq_socket.send_pyobj(self.dataOut)
+                        time.sleep(0.1)
                         self.zmq_socket.close()
                     if self.client:
                         self.client.loop_stop()
                         self.client.disconnect()
             class ReceiverData(ProcessingUnit):
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     self.isConfig = False
                     server = kwargs.get('server', 'zmq.pipe')
                     if 'tcp://' in server:
                         address = server
                     else:
                         address = 'ipc:///tmp/%s' % server
                     self.address = address
                     self.dataOut = JROData()
                 def setup(self):
                     self.context = zmq.Context()
                     self.receiver = self.context.socket(zmq.PULL)
                     self.receiver.bind(self.address)
                     time.sleep(0.5)
-                    print '[Starting] ReceiverData from {}'.format(self.address)
+                    log.success('ReceiverData from {}'.format(self.address))
                 def run(self):
                     if not self.isConfig:
                         self.setup()
                         self.isConfig = True
                     self.dataOut = self.receiver.recv_pyobj()
-                    print '[Receiving] {} - {}'.format(self.dataOut.type,
+                    log.log('{} - {}'.format(self.dataOut.type,
-                                                           self.dataOut.datatime.ctime())
+                                             self.dataOut.datatime.ctime(),),
+                            'Receiving')
             class PlotterReceiver(ProcessingUnit, Process):
                 throttle_value = 5
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     Process.__init__(self)
                     self.mp = False
                     self.isConfig = False
                     self.isWebConfig = False
-                    self.plottypes = []
                     self.connections = 0
                     server = kwargs.get('server', 'zmq.pipe')
                     plot_server = kwargs.get('plot_server', 'zmq.web')
                     if 'tcp://' in server:
                         address = server
                     else:
                         address = 'ipc:///tmp/%s' % server
                     if 'tcp://' in plot_server:
                         plot_address = plot_server
                     else:
                         plot_address = 'ipc:///tmp/%s' % plot_server
                     self.address = address
                     self.plot_address = plot_address
                     self.plottypes = [s.strip() for s in kwargs.get('plottypes', 'rti').split(',')]
                     self.realtime = kwargs.get('realtime', False)
                     self.throttle_value = kwargs.get('throttle', 5)
                     self.sendData = self.initThrottle(self.throttle_value)
+                    self.dates = []
                     self.setup()
                 def setup(self):
-                    self.data = {}
+                    self.data = Data(self.plottypes, self.throttle_value)
-                    self.data['times'] = []
+                    self.isConfig = True
-                    for plottype in self.plottypes:
-                        self.data[plottype] = {}
-                    self.data['noise'] = {}
-                    self.data['throttle'] = self.throttle_value
-                    self.data['ENDED'] = False
-                    self.isConfig = True
-                    self.data_web = {}
                 def event_monitor(self, monitor):
                     events = {}
                     for name in dir(zmq):
                         if name.startswith('EVENT_'):
                             value = getattr(zmq, name)
                             events[value] = name
                     while monitor.poll():
                         evt = recv_monitor_message(monitor)
                         if evt['event'] == 32:
                             self.connections += 1
                         if evt['event'] == 512:
                             pass
-                        if self.connections == 0 and self.started is True:
-                            self.ended = True
                         evt.update({'description': events[evt['event']]})
                         if evt['event'] == zmq.EVENT_MONITOR_STOPPED:
                             break
                     monitor.close()
-                    print("event monitor thread done!")
+                    print('event monitor thread done!')
                 def initThrottle(self, throttle_value):
                     @throttle(seconds=throttle_value)
                     def sendDataThrottled(fn_sender, data):
                         fn_sender(data)
                     return sendDataThrottled
                 def send(self, data):
-                    # print '[sending] data=%s size=%s' % (data.keys(), len(data['times']))
+                    log.success('Sending {}'.format(data), self.name)
                     self.sender.send_pyobj(data)
-                def update(self):
-                    t = self.dataOut.utctime
-                    if t in self.data['times']:
-                        return
-                    self.data['times'].append(t)
-                    self.data['dataOut'] = self.dataOut
-                    for plottype in self.plottypes:
-                        if plottype == 'spc':
-                            z = self.dataOut.data_spc/self.dataOut.normFactor
-                            self.data[plottype] = 10*numpy.log10(z)
-                            self.data['noise'][t] = 10*numpy.log10(self.dataOut.getNoise()/self.dataOut.normFactor)
-                        if plottype == 'cspc':
-                            jcoherence = self.dataOut.data_cspc/numpy.sqrt(self.dataOut.data_spc*self.dataOut.data_spc)
-                            self.data['cspc_coh'] = numpy.abs(jcoherence)
-                            self.data['cspc_phase'] = numpy.arctan2(jcoherence.imag, jcoherence.real)*180/numpy.pi
-                        if plottype == 'rti':
-                            self.data[plottype][t] = self.dataOut.getPower()
-                        if plottype == 'snr':
-                            self.data[plottype][t] = 10*numpy.log10(self.dataOut.data_SNR)
-                        if plottype == 'dop':
-                            self.data[plottype][t] = 10*numpy.log10(self.dataOut.data_DOP)
-                        if plottype == 'mean':
-                            self.data[plottype][t] = self.dataOut.data_MEAN
-                        if plottype == 'std':
-                            self.data[plottype][t] = self.dataOut.data_STD
-                        if plottype == 'coh':
-                            self.data[plottype][t] = self.dataOut.getCoherence()
-                        if plottype == 'phase':
-                            self.data[plottype][t] = self.dataOut.getCoherence(phase=True)
-                        if plottype == 'output':
-                            self.data[plottype][t] = self.dataOut.data_output
-                        if plottype == 'param':
-                            self.data[plottype][t] = self.dataOut.data_param
-                        if self.realtime:
-                            self.data_web['timestamp'] = t
-                            if plottype == 'spc':
-                                self.data_web[plottype] = roundFloats(decimate(self.data[plottype]).tolist())
-                            elif plottype == 'cspc':
-                                self.data_web['cspc_coh'] = roundFloats(decimate(self.data['cspc_coh']).tolist())
-                                self.data_web['cspc_phase'] = roundFloats(decimate(self.data['cspc_phase']).tolist())
-                            elif plottype == 'noise':
-                                self.data_web['noise'] = roundFloats(self.data['noise'][t].tolist())
-                            else:
-                                self.data_web[plottype] = roundFloats(decimate(self.data[plottype][t]).tolist())
-                            self.data_web['interval'] = self.dataOut.getTimeInterval()
-                            self.data_web['type'] = plottype
                 def run(self):
-                    print '[Starting] {} from {}'.format(self.name, self.address)
+                    log.success(
+                        'Starting from {}'.format(self.address),
+                        self.name
+                    )
                     self.context = zmq.Context()
                     self.receiver = self.context.socket(zmq.PULL)
                     self.receiver.bind(self.address)
                     monitor = self.receiver.get_monitor_socket()
                     self.sender = self.context.socket(zmq.PUB)
                     if self.realtime:
                         self.sender_web = self.context.socket(zmq.PUB)
                         self.sender_web.connect(self.plot_address)
                         time.sleep(1)
                     if 'server' in self.kwargs:
                         self.sender.bind("ipc:///tmp/{}.plots".format(self.kwargs['server']))
                     else:
                         self.sender.bind("ipc:///tmp/zmq.plots")
-                    time.sleep(3)
+                    time.sleep(2)
                     t = Thread(target=self.event_monitor, args=(monitor,))
                     t.start()
                     while True:
-                        self.dataOut = self.receiver.recv_pyobj()
+                        dataOut = self.receiver.recv_pyobj()
-                        # print '[Receiving] {} - {}'.format(self.dataOut.type,
+                        dt = datetime.datetime.fromtimestamp(dataOut.utctime).date()
-                        #                                    self.dataOut.datatime.ctime())
+                        sended = False
+                        if dt not in self.dates:
-                        self.update()
+                            if self.data:
+                                self.data.ended = True
+                                self.send(self.data)
+                                sended = True
+                            self.data.setup()
+                            self.dates.append(dt)
-                        if self.dataOut.firstdata is True:
+                        self.data.update(dataOut)
-                            self.data['STARTED'] = True
-                        if self.dataOut.finished is True:
+                        if dataOut.finished is True:
-                            self.send(self.data)
                             self.connections -= 1
-                            if self.connections == 0 and self.started:
+                            if self.connections == 0 and dt in self.dates:
-                                self.ended = True
+                                self.data.ended = True
-                                self.data['ENDED'] = True
                                 self.send(self.data)
-                                self.setup()
+                                self.data.setup()
-                                self.started = False
                         else:
                             if self.realtime:
                                 self.send(self.data)
-                                self.sender_web.send_string(json.dumps(self.data_web))
+                                # self.sender_web.send_string(self.data.jsonify())
                             else:
-                                self.sendData(self.send, self.data)
+                                if not sended:
-                            self.started = True
+                                    self.sendData(self.send, self.data)
-                        self.data['STARTED'] = False
                     return
                 def sendToWeb(self):
                     if not self.isWebConfig:
                         context = zmq.Context()
                         sender_web_config = context.socket(zmq.PUB)
                         if 'tcp://' in self.plot_address:
                             dum, address, port = self.plot_address.split(':')
                             conf_address = '{}:{}:{}'.format(dum, address, int(port)+1)
                         else:
                             conf_address = self.plot_address + '.config'
                         sender_web_config.bind(conf_address)
                         time.sleep(1)
                         for kwargs in self.operationKwargs.values():
                             if 'plot' in kwargs:
-                                print '[Sending] Config data to web for {}'.format(kwargs['code'].upper())
+                                log.success('[Sending] Config data to web for {}'.format(kwargs['code'].upper()))
                                 sender_web_config.send_string(json.dumps(kwargs))
-                        self.isWebConfig = True
+                        self.isWebConfig = True
  No newline at end of file

General Comments 0

Write
Preview

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

No TODOs yet

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

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