schain Commit - r1740:7f5b085e2124 · Jicamarca Repository

Drifts tested

joabAM -

r1740:7f5b085e2124

parent child

Context file:

r1740:7f5b085e2124

Collapse all files

schainpy/model/data/jrodata.py +3 0

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Definition of diferent Data objects for different types of data
             Here you will find the diferent data objects for the different types
             of data, this data objects must be used as dataIn or dataOut objects in
             processing units and operations. Currently the supported data objects are:
             Voltage, Spectra, SpectraHeis, Fits, Correlation and Parameters
             """
             import copy
             import numpy
             import datetime
             import json
             import schainpy.admin
             from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader,ProcessingHeader
             from schainpy.model.data import _noise
             SPEED_OF_LIGHT = 3e8
             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:
                     mean    :    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 _noise.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 list(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
                 def isReady(self):
                     return not self.flagNoData
             class JROData(GenericData):
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 type = None
                 datatype = None  # dtype but in string
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
                 nCohInt = None
                 windowOfFilter = 1
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 error = None
                 data = None
                 nmodes = None
                 metadata_list = ['heightList', 'timeZone', 'type']
                 ippFactor = 1 #Added to correct the freq and vel range for AMISR data
                 useInputBuffer = False
                 buffer_empty = True
                 codeList = []
                 azimuthList = []
                 elevationList = []
                 last_noise = None
                 __ipp = None
                 __ippSeconds = None
                 sampled_heightsFFT = None
                 pulseLength_TxA = None
                 deltaHeight = None
                 __code = None
                 __nCode = None
                 __nBaud = None
                 unitsDescription = "The units of the parameters are according to the International System of units (Seconds, Meter, Hertz, ...), except \
             the parameters related to distances such as heightList, or heightResolution wich are in Km"
                 def __str__(self):
                     return '{} - {}'.format(self.type, self.datatime())
                 def getNoise(self):
                     raise NotImplementedError
                 @property
                 def nChannels(self):
                     return len(self.channelList)
                 @property
                 def channelIndexList(self):
                     return list(range(self.nChannels))
                 @property
                 def nHeights(self):
                     return len(self.heightList)
                 def getDeltaH(self):
                     return self.heightList[1] - self.heightList[0]
                 @property
                 def ltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 @property
                 def datatime(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
                 ## Radar Controller Header must be immutable
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     #return self.radarControllerHeaderObj.ippSeconds
                     return self.__ippSeconds
                 @ippSeconds.setter
                 def ippSeconds(self, ippSeconds):
                     '''
                     '''
                     #self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     self.__ippSeconds = ippSeconds
                     self.__ipp = ippSeconds*SPEED_OF_LIGHT/2000.0
                 @property
                 def code(self):
                     '''
                     '''
                     # return self.radarControllerHeaderObj.code
                     return self.__code
                 @code.setter
                 def code(self, code):
                     '''
                     '''
                     # self.radarControllerHeaderObj.code = code
                     self.__code = code
                 @property
                 def nCode(self):
                     '''
                     '''
                     # return self.radarControllerHeaderObj.nCode
                     return self.__nCode
                 @nCode.setter
                 def nCode(self, ncode):
                     '''
                     '''
                     # self.radarControllerHeaderObj.nCode = ncode
                     self.__nCode = ncode
                 @property
                 def nBaud(self):
                     '''
                     '''
                     # return self.radarControllerHeaderObj.nBaud
                     return self.__nBaud
                 @nBaud.setter
                 def nBaud(self, nbaud):
                     '''
                     '''
                     # self.radarControllerHeaderObj.nBaud = nbaud
                     self.__nBaud = nbaud
                 @property
                 def ipp(self):
                     '''
                     '''
                     # return self.radarControllerHeaderObj.ipp
                     return self.__ipp
                 @ipp.setter
                 def ipp(self, ipp):
                     '''
                     '''
                     # self.radarControllerHeaderObj.ipp = ipp
                     self.__ipp = ipp
                 @property
                 def metadata(self):
                     '''
                     '''
                     return {attr: getattr(self, attr) for attr in self.metadata_list}
             class Voltage(JROData):
                 dataPP_POW   = None
                 dataPP_DOP   = None
                 dataPP_WIDTH = None
                 dataPP_SNR   = None
                 # To use oper
                 flagProfilesByRange = False
                 nProfilesByRange = None
                 max_nIncohInt = 1
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagCohInt = False
                     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
                     self.ippFactor=1
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel,ymin_index:ymax_index]
                         nChannels = 1
                     else:
                         data = self.data[:,ymin_index:ymax_index]
                         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,ymin_index=None, ymax_index=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel,ymin_index, ymax_index)
                     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
+                @property
+                def data_pow(self):
+                    return self.getPower()
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Spectra(JROData):
                 data_outlier = None
                 flagProfilesByRange = False
                 nProfilesByRange = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.data_dc = None
                     self.data_spc = None
                     self.data_cspc = None
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.type = "Spectra"
                     self.timeZone = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = 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.beacon_heiIndexList = []
                     self.noise_estimation = None
                     self.codeList = []
                     self.azimuthList = []
                     self.elevationList = []
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp','nIncohInt', 'nFFTPoints', 'nProfiles']
                 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)
                         noise[channel] = hildebrand_sekhon(daux, self.max_nIncohInt[channel])
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         # this was estimated by getNoise Operation defined in jroproc_spectra.py
                         return self.noise_estimation
                     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.)
                     if self.nmodes:
                         return velrange/self.nmodes
                     else:
                         return velrange
                 @property
                 def nPairs(self):
                     return len(self.pairsList)
                 @property
                 def pairsIndexList(self):
                     return list(range(self.nPairs))
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         try:
                             pwcode = numpy.sum(self.code[0]**2)
                         except Exception as e:
                             log.warning("Failed pwcode read, setting to 1")
                             pwcode = 1
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
                     if self.flagProfilesByRange:
                         normFactor *= (self.nProfilesByRange/self.nProfilesByRange.max())
                     return normFactor
                 @property
                 def flag_cspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 @property
                 def flag_dc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
                         return self.nmodes*timeInterval
                     else:
                         return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     power = numpy.zeros( (self.nChannels,self.nHeights) )
                     for ch in range(self.nChannels):
                         z = None
                         if hasattr(factor,'shape'):
                             if factor.ndim > 1:
                                 z = self.data_spc[ch]/factor[ch]
                             else:
                                 z = self.data_spc[ch]/factor
                         else:
                             z = self.data_spc[ch]/factor
                         z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                         avg = numpy.average(z, axis=0)
                         power[ch] = 10 * numpy.log10(avg)
                     return power
                 @property
                 def max_nIncohInt(self):
                     ints = numpy.zeros(self.nChannels)
                     for ch in range(self.nChannels):
                         if hasattr(self.nIncohInt,'shape'):
                             if self.nIncohInt.ndim > 1:
                                 ints[ch,] = self.nIncohInt[ch].max()
                             else:
                                 ints[ch,] = self.nIncohInt
                                 self.nIncohInt = int(self.nIncohInt)
                         else:
                             ints[ch,] = self.nIncohInt
                     return ints
                 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", value)
                     return
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
             class SpectraHeis(Spectra):
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nIncohInt
             class Fits(JROData):
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
                     self.timeZone = 0
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Correlation(JROData):
                 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 = 0
                     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[list(range(0, 1))] = ind_vel[list(
                             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(list(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
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nProfiles
                 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
                 @property
                 def normFactor(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
             class Parameters(Spectra):
                 groupList = None  # List of Pairs, Groups, etc
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
                 abscissaList = None  # Abscissa, can be velocities, lags or time
                 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
                 GauSPC = None  # Fit gaussian SPC
                 data_outlier = None
                 data_vdrift = None
                 radarControllerHeaderTxt=None #header Controller like text
                 txPower = None
                 flagProfilesByRange = False
                 nProfilesByRange = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.type = "Parameters"
                     self.timeZone = 0
                 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
                 @property
                 def timeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
             class PlotterData(object):
                 '''
                 Object to hold data to be plotted
                 '''
                 MAXNUMX = 200
                 MAXNUMY = 200
                 def __init__(self, code, exp_code, localtime=True):
                     self.key = code
                     self.exp_code = exp_code
                     self.ready = False
                     self.flagNoData = False
                     self.localtime = localtime
                     self.data = {}
                     self.meta = {}
                     self.__heights = []
                 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.data)
                 def __getitem__(self, key):
                     if isinstance(key, int):
                         return self.data[self.times[key]]
                     elif isinstance(key, str):
                         ret = numpy.array([self.data[x][key] for x in self.times])
                         if ret.ndim > 1:
                             ret = numpy.swapaxes(ret, 0, 1)
                         return ret
                 def __contains__(self, key):
                     return key in self.data[self.min_time]
                 def setup(self):
                     '''
                     Configure object
                     '''
                     self.type = ''
                     self.ready = False
                     del self.data
                     self.data = {}
                     self.__heights = []
                     self.__all_heights = set()
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     if len(self.data[self.min_time][key]):
                         return self.data[self.min_time][key].shape
                     return (0,)
                 def update(self, data, tm, meta={}):
                     '''
                     Update data object with new dataOut
                     '''
                     self.data[tm] = data
                     for key, value in meta.items():
                         setattr(self, key, value)
                 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 list(self.data[key].items()):
                             h = self.__heights[self.times.tolist().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, tm, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
                     meta = {}
                     meta['xrange'] = []
                     dy = int(len(self.yrange)/self.MAXNUMY) + 1
                     tmp = self.data[tm][self.key]
                     shape = tmp.shape
                     if len(shape) == 2:
                         data = self.roundFloats(self.data[tm][self.key][::, ::dy].tolist())
                     elif len(shape) == 3:
                         dx = int(self.data[tm][self.key].shape[1]/self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[tm][self.key][::, ::dx, ::dy].tolist())
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
                     else:
                         data = self.roundFloats(self.data[tm][self.key].tolist())
                     ret = {
                         'plot': plot_name,
                         'code': self.exp_code,
                         'time': float(tm),
                         'data': data,
                         }
                     meta['type'] = plot_type
                     meta['interval'] = float(self.interval)
                     meta['localtime'] = self.localtime
                     meta['yrange'] = self.roundFloats(self.yrange[::dy].tolist())
                     meta.update(self.meta)
                     ret['metadata'] = meta
                     return json.dumps(ret)
                 @property
                 def times(self):
                     '''
                     Return the list of times of the current data
                     '''
                     ret = [t for t in self.data]
                     ret.sort()
                     return numpy.array(ret)
                 @property
                 def min_time(self):
                     '''
                     Return the minimun time value
                     '''
                     return self.times[0]
                 @property
                 def max_time(self):
                     '''
                     Return the maximun time value
                     '''
                     return self.times[-1]
                 # @property
                 # def heights(self):
                 #     '''
                 #     Return the list of heights of the current data
                 #     '''
                 #     return numpy.array(self.__heights[-1])
                 @staticmethod
                 def roundFloats(obj):
                     if isinstance(obj, list):
                         return list(map(PlotterData.roundFloats, obj))
                     elif isinstance(obj, float):
                         return round(obj, 2)

schainpy/model/graphics/jroplot_parameters.py +1 -1

             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DobleGaussianPlot(SpectraPlot):
                 '''
                 Plot for Double Gaussian Plot
                 '''
                 CODE = 'gaussian_fit'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
                 '''
                 Plot SpectraCut with Double Gaussian Fit
                 '''
                 CODE = 'cut_gaussian_fit'
             class SpectralFitObliquePlot(SpectraPlot):
                 '''
                 Plot for Spectral Oblique
                 '''
                 CODE = 'spc_moments'
                 colormap = 'jet'
                 plot_type = 'pcolor'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.update_list(dataOut)
                     meta = {}
                     data = {
                         'snr': 10 * numpy.log10(dataOut.data_snr)
                     }
                     return data, meta
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'RdBu_r'
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {
                         'dop': dataOut.data_dop
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
                     }
                     try:
                         data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     except:
                         pass
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {
                         'width': dataOut.data_width
                     }
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Range [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             try:
                                ax.collections.remove(ax.collections[0])
                             except:
                                pass
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(# r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}\N{DEGREE SIGN}'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}\N{DEGREE SIGN}'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class TxPowerPlot(Plot):
                 '''
                 Plot for TX Power from external file
                 '''
                 CODE = 'tx_power'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Power [kW]'
                     self.xlabel = 'Time'
                     self.titles = ['TX power']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                     #if not self.titles:
                     self.titles = ['TX Power Plot']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['tx_power'] = dataOut.txPower/1000
                     meta['yrange'] = numpy.array([])
                     #print(dataOut.txPower/1000)
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['tx_power']
                     if self.axes[0].firsttime:
                         if self.ymin is None: self.ymin = 0
                         if self.ymax is None: self.ymax = numpy.nanmax(Y) + 5
                         if self.ymax == 5:
                             self.ymax = 250
                             self.ymin = 100
                         self.axes[0].plot(x, Y, lw=1, label='Power')
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         self.axes[0].lines[0].set_data(x, Y)

schainpy/model/graphics/jroplot_spectra.py +21 -14

             # Copyright (c) 2012-2021 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plot Spectra data
             """
             import os
             import numpy
             import datetime
             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             from itertools import combinations
             from matplotlib.ticker import LinearLocator
             from schainpy.model.utils.BField import BField
             from scipy.interpolate import splrep
             from scipy.interpolate import splev
             from matplotlib import __version__ as plt_version
             if plt_version >='3.3.4':
                 EXTRA_POINTS = 0
             else:
                 EXTRA_POINTS = 1
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 channelList = []
                 elevationList = []
                 azimuthList = []
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 3.4 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 5.2 * self.ncols
                     else:
                         self.width = 4.2* self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.12})
                     self.ylabel = 'Range [km]'
                 def update_list(self,dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                     if len(self.elevationList) == 0:
                         self.elevationList = dataOut.elevationList
                     if len(self.azimuthList) == 0:
                         self.azimuthList = dataOut.azimuthList
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {}
                     meta = {}
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
-                    noise = 10*numpy.log10(dataOut.getNoise()/norm)
+                    if dataOut.type == "Parameters":
-                    z = numpy.zeros((dataOut.nChannels, dataOut.nFFTPoints, dataOut.nHeights))
+                        noise = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
-                    for ch in range(dataOut.nChannels):
+                        spc = 10*numpy.log10(dataOut.data_spc/(dataOut.nProfiles))
-                        if hasattr(dataOut.normFactor,'ndim'):
+                    else:
-                            if dataOut.normFactor.ndim > 1:
+                        noise = 10*numpy.log10(dataOut.getNoise()/norm)
-                                z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
+                        z = numpy.zeros((dataOut.nChannels, dataOut.nFFTPoints, dataOut.nHeights))
+                        for ch in range(dataOut.nChannels):
+                            if hasattr(dataOut.normFactor,'ndim'):
+                                if dataOut.normFactor.ndim > 1:
+                                    z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
+                                else:
+                                    z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
                             else:
                                 z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
-                        else:
-                            z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
-                    z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
+                        z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
-                    spc = 10*numpy.log10(z)
+                        spc = 10*numpy.log10(z)
                     data['spc'] = spc
                     data['rti'] = spc.mean(axis=1)
                     data['noise'] = noise
                     meta['xrange'] = (dataOut.getFreqRange(EXTRA_POINTS)/1000., dataOut.getAcfRange(EXTRA_POINTS), dataOut.getVelRange(EXTRA_POINTS))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if (self.CODE == 'spc_moments') | (self.CODE == 'gaussian_fit'):
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][0]
                         # noise = data['noise'][n]
                         if self.CODE == 'spc_moments':
                             mean = data['moments'][n, 1]
                         if self.CODE == 'gaussian_fit':
                             gau0 = data['gaussfit'][n][2,:,0]
                             gau1 = data['gaussfit'][n][2,:,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0 = ax.plot(gau0, y, color='r', lw=1)[0]
                                 ax.plt_gau1 = ax.plot(gau1, y, color='y', lw=1)[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0.set_data(gau0, y)
                                 ax.plt_gau1.set_data(gau1, y)
                         if len(self.azimuthList) > 0 and len(self.elevationList) > 0:
                             self.titles.append('CH {}: {:2.1f}elv {:2.1f}az {:3.2f}dB'.format(self.channelList[n], noise, self.elevationList[n], self.azimuthList[n]))
                         else:
                             self.titles.append('CH {}:  {:3.2f}dB'.format(self.channelList[n], noise))
             class SpectraObliquePlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc_oblique'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 def setup(self):
                     self.xaxis = "oblique"
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     data['shift1'] = dataOut.Dop_EEJ_T1[0]
                     data['shift2'] = dataOut.Dop_EEJ_T2[0]
                     data['max_val_2'] = dataOut.Oblique_params[0,-1,:]
                     data['shift1_error'] = dataOut.Err_Dop_EEJ_T1[0]
                     data['shift2_error'] = dataOut.Err_Dop_EEJ_T2[0]
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         shift1 = data['shift1']
                         shift2 = data['shift2']
                         max_val_2 = data['max_val_2']
                         err1 = data['shift1_error']
                         err2 = data['shift2_error']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                         else:
                             self.ploterr1.remove()
                             self.ploterr2.remove()
                             self.ploterr3.remove()
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 realChannels = None
                 crossPairs = None
                 def setup(self):
                     self.ncols = 4
                     self.nplots = len(self.data.pairs) * 2
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.1 * self.ncols
                     self.height = 2.6 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
                     meta['xrange'] = (dataOut.getFreqRange(EXTRA_POINTS)/1000., dataOut.getAcfRange(EXTRA_POINTS), dataOut.getVelRange(EXTRA_POINTS))
                     rawPairs = list(combinations(list(range(dataOut.nChannels)), 2))
                     meta['pairs'] = rawPairs
                     if self.crossPairs == None:
                         self.crossPairs = dataOut.pairsList
                     tmp = []
                     for n, pair in enumerate(meta['pairs']):
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         tmp.append(coh)
                         tmp.append(phase)
                     data['cspc'] = numpy.array(tmp)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     cspc = data['cspc']
                     for n in range(len(self.data.pairs)):
                         pair = self.crossPairs[n]
                         coh = cspc[n*2]
                         phase = cspc[n*2+1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=self.zmin_coh,
                                                    vmax=self.zmax_coh,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[2 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra4Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     nspc = self.data['spc']
                     spc = self.data['cspc'][0]
                     cspc = self.data['cspc'][1]
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
                             ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(nspc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x , y, numpy.flip(nspc[pair[1]],axis=0).T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(nspc[pair[1]],axis=0).T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(coh,axis=0).T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(coh,axis=0).T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(phase,axis=0).T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(phase,axis=0).T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra2Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 1
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     cspc = self.data['cspc'][1]
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         out = cspc[n]
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         cross = 10*numpy.log10(z)
                         ax = self.axes[1 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
             class CrossSpectra3Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 3
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 3
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     cspc = self.data['cspc'][1]
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         out = cspc[n]
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         cross = 10*numpy.log10(z)
                         out_r= out.real/self.data.nFactor
                         out_i= out.imag/self.data.nFactor
                         ax = self.axes[3 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_r.T,
                                                    vmin=-1.e6,
                                                    vmax=0,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_r.T.ravel())
                         self.titles.append(
                             'Cross Spectra Real Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 2]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_i.T,
                                                    vmin=-1.e6,
                                                    vmax=1.e6,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_i.T.ravel())
                         self.titles.append(
                             'Cross Spectra Imag Ch{} * Ch{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 titles = None
                 channelList = []
                 elevationList = []
                 azimuthList = []
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     #self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nplots)]
                 def update_list(self,dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                     if len(self.elevationList) == 0:
                         self.elevationList = dataOut.elevationList
                     if len(self.azimuthList) == 0:
                         self.azimuthList = dataOut.azimuthList
                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.update_list(dataOut)
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
                     noise = 10*numpy.log10(dataOut.getNoise()/norm)
                     data['noise'] = noise
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.array(self.z, dtype=float)
                     self.z = numpy.ma.masked_invalid(self.z)
                     try:
                         if self.channelList != None:
                             if len(self.elevationList) > 0 and len(self.azimuthList) > 0:
                                 self.titles = ['{}  Channel {} ({:2.1f} Elev,  {:2.1f} Azth)'.format(
                                     self.CODE.upper(), x, self.elevationList[x], self.azimuthList[x]) for x in self.channelList]
                             else:
                                 self.titles = ['{}  Channel {}'.format(
                                     self.CODE.upper(), x) for x in self.channelList]
                     except:
                         if self.channelList.any() != None:
                             if len(self.elevationList) > 0 and len(self.azimuthList) > 0:
                                 self.titles = ['{}  Channel {} ({:2.1f} Elev,  {:2.1f} Azth)'.format(
                                     self.CODE.upper(), x, self.elevationList[x], self.azimuthList[x]) for x in self.channelList]
                             else:
                                 self.titles = ['{} Channel {}'.format(
                                     self.CODE.upper(), x) for x in self.channelList]
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
-                                    data['rti'][n], self.y)[0]
+                                    data[self.CODE][n], self.y)[0]
                                 if "noise" in self.data:
                                     ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(data['noise'][n], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             # ax.collections.remove(ax.collections[0]) #  error while running
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
-                                ax.plot_profile.set_data(data['rti'][n], self.y)
+                                ax.plot_profile.set_data(data[self.CODE][n], self.y)
                                 if "noise" in self.data:
                                     ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(data['noise'][n], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
             class SpectrogramPlot(Plot):
                 '''
                 Plot for Spectrogram data
                 '''
                 CODE = 'Spectrogram_Profile'
                 colormap = 'binary'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':1.2, 'left': 0.1, 'bottom': 0.12, 'right':0.95})
                     self.titles = []
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     maxHei = 1620#+12000
                     indb = numpy.where(dataOut.heightList <= maxHei)
                     hei = indb[0][-1]
                     factor = dataOut.nIncohInt
                     z = dataOut.data_spc[:,:,hei] / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     data['Spectrogram_Profile'] = 10 * numpy.log10(z)
                     data['hei'] = hei
                     data['DH'] = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
                     data['nProfiles'] = dataOut.nProfiles
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.z = self.data[self.CODE]
                     self.y = self.data.xrange[0]
                     hei = self.data['hei'][-1]
                     DH = self.data['DH'][-1]
                     nProfiles = self.data['nProfiles'][-1]
                     self.ylabel = "Frequency (kHz)"
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             # ax.collections.remove(ax.collections[0]) #  error while running
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 titles = None
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['coh'] = dataOut.getCoherence()
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['phase'] = dataOut.getCoherence(phase=True)
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
+                    self.titles = ['Noise Plot']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
+                    noise =  10*numpy.log10(dataOut.getNoise())
+                    noise = noise.reshape(dataOut.nChannels, 1)
+                    data['noise'] = noise
                     meta['yrange'] = numpy.array([])
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['noise']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5
                         self.ymax = numpy.nanmax(Y) + 5
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
             class PowerProfilePlot(Plot):
                 CODE = 'pow_profile'
                 plot_type = 'scatter'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data[self.CODE] = dataOut.getPower()
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.y = y
                     x = self.data[-1][self.CODE]
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 heights = []
                 channelList = []
                 maintitle = "Spectra Cuts"
                 flag_setIndex = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 4.5 * self.ncols + 2.5
                     self.height = 4.8 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.9, 'bottom':0.08})
                     if len(self.selectedHeightsList) > 0:
                         self.maintitle = "Spectra Cut"# for %d km " %(int(self.selectedHeight))
                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                     self.heights = dataOut.heightList
                     #print("sels: ",self.selectedHeightsList)
                     if len(self.selectedHeightsList)>0 and not self.flag_setIndex:
                         for sel_height in self.selectedHeightsList:
                             index_list = numpy.where(self.heights >= sel_height)
                             index_list = index_list[0]
                             self.height_index.append(index_list[0])
                         #print("sels i:"", self.height_index)
                         self.flag_setIndex = True
                         #print(self.height_index)
                     data = {}
                     meta = {}
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter#*dataOut.nFFTPoints
                     n0 = 10*numpy.log10(dataOut.getNoise()/norm)
                     noise = numpy.repeat(n0,(dataOut.nFFTPoints*dataOut.nHeights)).reshape(dataOut.nChannels,dataOut.nFFTPoints,dataOut.nHeights)
                     z = []
                     for ch in range(dataOut.nChannels):
                         if hasattr(dataOut.normFactor,'shape'):
                             z.append(numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
                         else:
                             z.append(numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
                     z = numpy.asarray(z)
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     spc = 10*numpy.log10(z)
                     data['spc'] = spc - noise
                     meta['xrange'] = (dataOut.getFreqRange(EXTRA_POINTS)/1000., dataOut.getAcfRange(EXTRA_POINTS), dataOut.getVelRange(EXTRA_POINTS))
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][0:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     z = self.data[-1]['spc']
                     #print(z.shape)
                     if len(self.height_index) > 0:
                         index = self.height_index
                     else:
                         index = numpy.arange(0, len(y), int((len(y))/9))
                     #print("inde x ", index, self.axes)
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z)
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z)
                             ax.plt = ax.plot(x, z[n, :, index].T)
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right', prop={'size': 8})
                             ax.minorticks_on()
                             ax.grid(which='major', axis='both')
                             ax.grid(which='minor', axis='x')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, index[i]])
                         self.titles.append('CH {}'.format(self.channelList[n]))
                     plt.suptitle(self.maintitle,  fontsize=10)
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             #####################################
             class NoiselessSpectraPlot(Plot):
                 '''
                 Plot for Spectra data, subtracting
                 the noise in all channels, using for
                 amisr-14 data
                 '''
                 CODE = 'noiseless_spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 channelList = []
                 last_noise = None
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 3.5 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 5.8 * self.ncols
                     else:
                         self.width = 4.8* self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.92, 'bottom': 0.12})
                     self.ylabel = 'Range [km]'
                 def update_list(self,dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                 def update(self, dataOut):
                     self.update_list(dataOut)
                     data = {}
                     meta = {}
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
                     n0 = (dataOut.getNoise()/norm)
                     noise = numpy.repeat(n0,(dataOut.nFFTPoints*dataOut.nHeights)).reshape(dataOut.nChannels,dataOut.nFFTPoints,dataOut.nHeights)
                     noise = 10*numpy.log10(noise)
                     z = numpy.zeros((dataOut.nChannels, dataOut.nFFTPoints, dataOut.nHeights))
                     for ch in range(dataOut.nChannels):
                         if hasattr(dataOut.normFactor,'ndim'):
                             if dataOut.normFactor.ndim > 1:
                                 z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor[ch]))
                             else:
                                 z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
                         else:
                             z[ch] = (numpy.divide(dataOut.data_spc[ch],dataOut.normFactor))
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     spc = 10*numpy.log10(z)
                     data['spc'] = spc - noise
                     #print(spc.shape)
                     data['rti'] = spc.mean(axis=1)
                     data['noise'] = noise
                     # data['noise'] = noise
                     meta['xrange'] = (dataOut.getFreqRange(EXTRA_POINTS)/1000., dataOut.getAcfRange(EXTRA_POINTS), dataOut.getVelRange(EXTRA_POINTS))
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         #noise = data['noise'][n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                         self.titles.append('CH {}'.format(self.channelList[n]))
             class NoiselessRTIPlot(RTIPlot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'noiseless_rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 titles = None
                 channelList = []
                 elevationList = []
                 azimuthList = []
                 last_noise = None
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     #print("dataChannels ",self.data.channels)
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     #self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.08, 'bottom': 0.2, 'right':0.94})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nplots)]
                 def update_list(self,dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                     if len(self.elevationList) == 0:
                         self.elevationList = dataOut.elevationList
                     if len(self.azimuthList) == 0:
                         self.azimuthList = dataOut.azimuthList
                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.update_list(dataOut)
                     data = {}
                     meta = {}
                     #print(dataOut.max_nIncohInt, dataOut.nIncohInt)
                     #print(dataOut.windowOfFilter,dataOut.nCohInt,dataOut.nProfiles,dataOut.max_nIncohInt,dataOut.nIncohInt
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
                     n0 = 10*numpy.log10(dataOut.getNoise()/norm)
                     data['noise'] = n0
                     noise = numpy.repeat(n0,dataOut.nHeights).reshape(dataOut.nChannels,dataOut.nHeights)
                     noiseless_data = dataOut.getPower() - noise
                     #print("power, noise:", dataOut.getPower(), n0)
                     #print(noise)
                     #print(noiseless_data)
                     data['noiseless_rti'] = noiseless_data
                     return data, meta
                 def plot(self):
                     from matplotlib import pyplot as plt
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['noiseless_rti']
                     self.z = numpy.array(self.z, dtype=float)
                     self.z = numpy.ma.masked_invalid(self.z)
                     try:
                         if self.channelList != None:
                             if len(self.elevationList) > 0 and len(self.azimuthList) > 0:
                                 self.titles = ['{}  Channel {} ({:2.1f} Elev,  {:2.1f} Azth)'.format(
                                     self.CODE.upper(), x, self.elevationList[x], self.azimuthList[x]) for x in self.channelList]
                             else:
                                 self.titles = ['{}  Channel {}'.format(
                                     self.CODE.upper(), x) for x in self.channelList]
                     except:
                         if self.channelList.any() != None:
                             if len(self.elevationList) > 0 and len(self.azimuthList) > 0:
                                 self.titles = ['{}  Channel {} ({:2.1f} Elev,  {:2.1f} Azth)'.format(
                                     self.CODE.upper(), x, self.elevationList[x], self.azimuthList[x]) for x in self.channelList]
                             else:
                                 self.titles = ['{} Channel {}'.format(
                                     self.CODE.upper(), x) for x in self.channelList]
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     dummy_var = self.axes #Extrañamente esto actualiza el valor axes
                     #print("plot shapes ", z.shape, x.shape, y.shape)
                     #print(self.axes)
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             if (n+1) == len(self.channelList):
                                 ax.set_xlabel('Time')
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(data['noiseless_rti'][n], self.y)[0]
                         else:
                             # ax.collections.remove(ax.collections[0]) #  error while running
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(data['noiseless_rti'][n], self.y)
                                 # if "noise" in self.data:
                                 #     #ax.plot_noise.set_data(numpy.repeat(data['noise'][n], len(self.y)), self.y)
                                 #     ax.plot_noise.set_data(data['noise'][n], self.y)
             class OutliersRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'outlier_rtc' # Range Time Counts
                 colormap = 'cool'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('outlier_rtc')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.08, 'bottom': 0.2, 'right':0.94})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = ['Outliers Ch:{}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     data['outlier_rtc'] = dataOut.data_outlier
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['outlier_rtc']
                     #self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         data = self.data[-1]
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(data['outlier_rtc'][n], self.y)[0]
                                 self.pf_axes[n].set_xlabel('')
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             # ax.collections.remove(ax.collections[0]) #  error while running
                             ax.plt = ax.pcolormesh(x, y, z[n].T ,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(data['outlier_rtc'][n], self.y)
                                 self.pf_axes[n].set_xlabel('')
             class NIncohIntRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'integrations_rtc' # Range Time Counts
                 colormap = 'BuGn'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('integrations_rtc')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.08, 'bottom': 0.2, 'right':0.94})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = ['Integration Ch:{}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     data['integrations_rtc'] = dataOut.nIncohInt
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['integrations_rtc']
                     #self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         data = self.data[-1]
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(data['integrations_rtc'][n], self.y)[0]
                                 self.pf_axes[n].set_xlabel('')
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             # ax.collections.remove(ax.collections[0]) #  error while running
                             ax.plt = ax.pcolormesh(x, y, z[n].T ,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(data['integrations_rtc'][n], self.y)
                                 self.pf_axes[n].set_xlabel('')
             class RTIMapPlot(Plot):
                 '''
                 Plot for RTI data
                 Example:
                 controllerObj = Project()
                 controllerObj.setup(id = '11', name='eej_proc', description=desc)
                 ##.......................................................................................
                 ##.......................................................................................
                 readUnitConfObj = controllerObj.addReadUnit(datatype='AMISRReader', path=inPath, startDate='2023/05/24',endDate='2023/05/24',
                                 startTime='12:00:00',endTime='12:45:59',walk=1,timezone='lt',margin_days=1,code = code,nCode = nCode,
                                 nBaud = nBaud,nOsamp = nosamp,nChannels=nChannels,nFFT=NFFT,
                                 syncronization=False,shiftChannels=0)
                 volts_proc = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
                 opObj01 = volts_proc.addOperation(name='Decoder', optype='other')
                 opObj01.addParameter(name='code', value=code, format='floatlist')
                 opObj01.addParameter(name='nCode', value=1, format='int')
                 opObj01.addParameter(name='nBaud', value=nBaud, format='int')
                 opObj01.addParameter(name='osamp', value=nosamp, format='int')
                 opObj12 = volts_proc.addOperation(name='selectHeights', optype='self')
                 opObj12.addParameter(name='minHei', value='90', format='float')
                 opObj12.addParameter(name='maxHei', value='150', format='float')
                 proc_spc = controllerObj.addProcUnit(datatype='SpectraProc', inputId=volts_proc.getId())
                 proc_spc.addParameter(name='nFFTPoints', value='8', format='int')
                 opObj11 = proc_spc.addOperation(name='IncohInt', optype='other')
                 opObj11.addParameter(name='n', value='1', format='int')
                 beamMapFile = "/home/japaza/Documents/AMISR_sky_mapper/UMET_beamcodes.csv"
                 opObj12 = proc_spc.addOperation(name='RTIMapPlot', optype='external')
                 opObj12.addParameter(name='selectedHeightsList', value='95, 100, 105, 110 ', format='int')
                 opObj12.addParameter(name='bField', value='100', format='int')
                 opObj12.addParameter(name='filename', value=beamMapFile, format='str')
                 '''
                 CODE = 'rti_skymap'
                 plot_type = 'scatter'
                 titles = None
                 colormap = 'jet'
                 channelList = []
                 elevationList = []
                 azimuthList = []
                 last_noise = None
                 flag_setIndex = False
                 heights = []
                 dcosx = []
                 dcosy = []
                 fullDcosy = None
                 fullDcosy = None
                 hindex = []
                 mapFile = False
                 #####  BField    ####
                 flagBField = False
                 dcosxB = []
                 dcosyB = []
                 Bmarker = ['+','*','D','x','s','>','o','^']
                 def setup(self):
                     self.xaxis = 'Range (Km)'
                     if len(self.selectedHeightsList) > 0:
                         self.nplots = len(self.selectedHeightsList)
                     else:
                         self.nplots = 4
                     self.ncols = int(numpy.ceil(self.nplots/2))
                     self.nrows = int(numpy.ceil(self.nplots/self.ncols))
                     self.ylabel = 'dcosy'
                     self.xlabel = 'dcosx'
                     self.colorbar = True
                     self.width = 6 + 4.1*self.nrows
                     self.height = 3 + 3.5*self.ncols
                     if self.extFile!=None:
                         try:
                             pointings =  numpy.genfromtxt(self.extFile, delimiter=',')
                             full_azi = pointings[:,1]
                             full_elev = pointings[:,2]
                             self.fullDcosx = numpy.cos(numpy.radians(full_elev))*numpy.sin(numpy.radians(full_azi))
                             self.fullDcosy = numpy.cos(numpy.radians(full_elev))*numpy.cos(numpy.radians(full_azi))
                             mapFile = True
                         except Exception as e:
                             self.extFile = None
                             print(e)
                 def update_list(self,dataOut):
                     if len(self.channelList) == 0:
                         self.channelList = dataOut.channelList
                     if len(self.elevationList) == 0:
                         self.elevationList = dataOut.elevationList
                     if len(self.azimuthList) == 0:
                         self.azimuthList = dataOut.azimuthList
                     a = numpy.radians(numpy.asarray(self.azimuthList))
                     e = numpy.radians(numpy.asarray(self.elevationList))
                     self.heights = dataOut.heightList
                     self.dcosx = numpy.cos(e)*numpy.sin(a)
                     self.dcosy = numpy.cos(e)*numpy.cos(a)
                     if len(self.bFieldList)>0:
                         datetObj = datetime.datetime.fromtimestamp(dataOut.utctime)
                         doy = datetObj.timetuple().tm_yday
                         year = datetObj.year
                         # self.dcosxB, self.dcosyB
                         ObjB = BField(year=year,doy=doy,site=2,heights=self.bFieldList)
                         [dcos, alpha, nlon, nlat] = ObjB.getBField()
                         alpha_location = numpy.zeros((nlon,2,len(self.bFieldList)))
                         for ih in range(len(self.bFieldList)):
                             alpha_location[:,0,ih] = dcos[:,0,ih,0]
                             for ilon in numpy.arange(nlon):
                                 myx = (alpha[ilon,:,ih])[::-1]
                                 myy = (dcos[ilon,:,ih,0])[::-1]
                                 tck = splrep(myx,myy,s=0)
                                 mydcosx = splev(ObjB.alpha_i,tck,der=0)
                                 myx = (alpha[ilon,:,ih])[::-1]
                                 myy = (dcos[ilon,:,ih,1])[::-1]
                                 tck = splrep(myx,myy,s=0)
                                 mydcosy = splev(ObjB.alpha_i,tck,der=0)
                                 alpha_location[ilon,:,ih] = numpy.array([mydcosx, mydcosy])
                             self.dcosxB.append(alpha_location[:,0,ih])
                             self.dcosyB.append(alpha_location[:,1,ih])
                         self.flagBField = True
                     if len(self.celestialList)>0:
                         #getBField(self.bFieldList, date)
                         #pass = kwargs.get('celestial', [])
                         pass
                 def update(self, dataOut):
                     if len(self.channelList) == 0:
                         self.update_list(dataOut)
                     if not self.flag_setIndex:
                         if len(self.selectedHeightsList)>0:
                             for sel_height in self.selectedHeightsList:
                                 index_list = numpy.where(self.heights >= sel_height)
                                 index_list = index_list[0]
                                 self.hindex.append(index_list[0])
                         self.flag_setIndex = True
                     data = {}
                     meta = {}
                     data['rti_skymap'] = dataOut.getPower()
                     norm = dataOut.nProfiles * dataOut.max_nIncohInt * dataOut.nCohInt  * dataOut.windowOfFilter
                     noise = 10*numpy.log10(dataOut.getNoise()/norm)
                     data['noise'] = noise
                     return data, meta
                 def plot(self):
                     self.x = self.dcosx
                     self.y = self.dcosy
                     self.z = self.data[-1]['rti_skymap']
                     self.z = numpy.array(self.z, dtype=float)
                     if len(self.hindex) > 0:
                         index = self.hindex
                     else:
                         index = numpy.arange(0, len(self.heights), int((len(self.heights))/4.2))
                     self.titles = ['Height {:.2f} km '.format(self.heights[i])+" " for i in index]
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(self.x)
                             self.xmin = self.xmin if self.xmin else numpy.nanmin(self.x)
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(self.z)
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(self.z)
                             if self.extFile!=None:
                                 ax.scatter(self.fullDcosx, self.fullDcosy, marker="+", s=20)
                             ax.plt = ax.scatter(self.x, self.y, c=self.z[:,index[n]], cmap = 'jet',vmin = self.zmin,
                                 s=60, marker="s", vmax = self.zmax)
                             ax.minorticks_on()
                             ax.grid(which='major', axis='both')
                             ax.grid(which='minor', axis='x')
                             if self.flagBField :
                                 for ih in range(len(self.bFieldList)):
                                     label = str(self.bFieldList[ih]) + ' km'
                                     ax.plot(self.dcosxB[ih], self.dcosyB[ih], color='k', marker=self.Bmarker[ih % 8],
                                                      label=label,   linestyle='--',  ms=4.0,lw=0.5)
                                 handles, labels = ax.get_legend_handles_labels()
                                 a = -0.05
                                 b = 1.15 - 1.19*(self.nrows)
                                 self.axes[0].legend(handles,labels, bbox_to_anchor=(a,b), prop={'size': (5.8+ 1.1*self.nplots)}, title='B Field ⊥')
                         else:
                             ax.plt = ax.scatter(self.x, self.y, c=self.z[:,index[n]], cmap = 'jet',vmin = self.zmin,
                                  s=80, marker="s", vmax = self.zmax)
                             if self.flagBField :
                                 for ih in range(len(self.bFieldList)):
                                     ax.plot (self.dcosxB[ih], self.dcosyB[ih], color='k', marker=self.Bmarker[ih % 8],
                                             linestyle='--', ms=4.0,lw=0.5)

schainpy/model/io/jroIO_param.py +6 -2

             import os
             import time
             import datetime
             import numpy
             import h5py
             import schainpy.admin
             from schainpy.model.data.jrodata import *
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.io.jroIO_base import *
             from schainpy.utils import log
             class HDFReader(Reader, ProcessingUnit):
                 """Processing unit to read HDF5 format files
                 This unit reads HDF5 files created with `HDFWriter` operation contains
                 by default two groups Data and Metadata all variables would be saved as `dataOut`
                 attributes.
                 It is possible to read any HDF5 file by given the structure in the `description`
                 parameter, also you can add extra values to metadata with the parameter `extras`.
                 Parameters:
                 -----------
                 path : str
                     Path where files are located.
                 startDate : date
                     Start date of the files
                 endDate : list
                     End date of the files
                 startTime : time
                     Start time of the files
                 endTime : time
                     End time of the files
                 description : dict, optional
                     Dictionary with the description of the HDF5 file
                 extras : dict, optional
                     Dictionary with extra metadata to be be added to `dataOut`
                 Attention:   Be carefull, add  attribute utcoffset, in the last part of reader in order to work in Local Time without time problems.
                 -----------
                 utcoffset='-18000'
                 Examples
                 --------
                 desc = {
                     'Data': {
                         'data_output': ['u', 'v', 'w'],
                         'utctime': 'timestamps',
                     }  ,
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 extras = {
                     'timeZone': 300
                 }
                 reader = project.addReadUnit(
                     name='HDFReader',
                     path='/path/to/files',
                     startDate='2019/01/01',
                     endDate='2019/01/31',
                     startTime='00:00:00',
                     endTime='23:59:59',
                     utcoffset='-18000'
                     # description=json.dumps(desc),
                     # extras=json.dumps(extras),
                     )
                 """
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'description', 'extras']
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.ext = ".hdf5"
                     self.optchar = "D"
                     self.meta = {}
                     self.data = {}
                     self.open_file = h5py.File
                     self.open_mode = 'r'
                     self.description = {}
                     self.extras = {}
                     self.filefmt = "*%Y%j***"
                     self.folderfmt = "*%Y%j"
                     self.utcoffset = 0
                     self.flagUpdateDataOut = False
                     self.dataOut = Parameters()
                     self.dataOut.error=False            ## NOTE: Importante definir esto antes inicio
                     self.dataOut.flagNoData = True
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             pathname, filename = os.path.split(fullpath)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     return
                 # def readFirstHeader(self):
                 #     '''Read metadata and data'''
                 #     self.__readMetadata()
                 #     self.__readData()
                 #     self.__setBlockList()
                 #     if 'type' in self.meta:
                 #         self.dataOut = eval(self.meta['type'])()
                 #     for attr in self.meta:
                 #         setattr(self.dataOut, attr, self.meta[attr])
                 #     self.blockIndex = 0
                 #     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata2()
                     self.__readData()
                     self.__setBlockList()
                     if 'type' in self.meta:
                         self.dataOut = eval(self.meta['type'])()
                     for attr in self.meta:
                         if "processingHeaderObj" in attr:
                             self.flagUpdateDataOut=True
                         at = attr.split('.')
                         if len(at) > 1:
                             setattr(eval("self.dataOut."+at[0]),at[1], self.meta[attr])
                         else:
                             setattr(self.dataOut, attr, self.meta[attr])
                     self.blockIndex = 0
                     if self.flagUpdateDataOut:
                         self.updateDataOut()
                     return
                 def updateDataOut(self):
                     self.dataOut.azimuthList = self.dataOut.processingHeaderObj.azimuthList
                     self.dataOut.elevationList = self.dataOut.processingHeaderObj.elevationList
                     self.dataOut.heightList = self.dataOut.processingHeaderObj.heightList
                     self.dataOut.ippSeconds = self.dataOut.processingHeaderObj.ipp
                     self.dataOut.elevationList = self.dataOut.processingHeaderObj.elevationList
                     self.dataOut.channelList = self.dataOut.processingHeaderObj.channelList
                     self.dataOut.nCohInt = self.dataOut.processingHeaderObj.nCohInt
                     self.dataOut.nFFTPoints = self.dataOut.processingHeaderObj.nFFTPoints
                     self.flagUpdateDataOut = False
                     self.dataOut.frequency = self.dataOut.radarControllerHeaderObj.frequency
                     #self.dataOut.heightList = self.dataOut.processingHeaderObj.heightList
                 def __setBlockList(self):
                     '''
                     Selects the data within the times defined
                     self.fp
                     self.startTime
                     self.endTime
                     self.blockList
                     self.blocksPerFile
                     '''
                     startTime = self.startTime
                     endTime = self.endTime
                     thisUtcTime = self.data['utctime'] + self.utcoffset
                     # self.interval = numpy.min(thisUtcTime[1:] - thisUtcTime[:-1])
                     thisDatetime = datetime.datetime.utcfromtimestamp(thisUtcTime[0])
                     self.startFileDatetime = thisDatetime
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     startUtcTime = (datetime.datetime.combine(thisDate, startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     endUtcTime = (datetime.datetime.combine(thisDate, endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     ind = numpy.where(numpy.logical_and(thisUtcTime >= startUtcTime, thisUtcTime < endUtcTime))[0]
                     self.blockList = ind
                     self.blocksPerFile = len(ind)
                     # self.blocksPerFile = len(thisUtcTime)
                     if len(ind)==0:
                         print("[Reading] Block No. %d/%d -> %s [Skipping]" % (self.blockIndex,
                                                                                   self.blocksPerFile,
                                                                                   thisDatetime))
                         self.setNextFile()
                     return
                 def __readMetadata(self):
                     '''
                     Reads Metadata
                     '''
                     meta = {}
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name][()]
                     if self.extras:
                         for key, value in self.extras.items():
                             meta[key] = value
                     self.meta = meta
                     return
                 def __readMetadata2(self):
                     '''
                     Reads Metadata
                     '''
                     meta = {}
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for item in grp.values():
                             name = item.name
                             if isinstance(item, h5py.Dataset):
                                 name = name.split("/")[-1]
                                 meta[name] = item[()]
                             else:
                                 grp2 = self.fp[name]
                                 Obj = name.split("/")[-1]
                                 for item2 in grp2.values():
                                     name2 = Obj+"."+item2.name.split("/")[-1]
                                     meta[name2] = item2[()]
                     if self.extras:
                         for key, value in self.extras.items():
                             meta[key] = value
                     self.meta = meta
                     return
                 def __readData(self):
                     data = {}
                     if self.description:
                         for key, value in self.description['Data'].items():
                             if isinstance(value, str):
                                 if isinstance(self.fp[value], h5py.Dataset):
                                     data[key] = self.fp[value][()]
                                 elif isinstance(self.fp[value], h5py.Group):
                                     array = []
                                     for ch in self.fp[value]:
                                         array.append(self.fp[value][ch][()])
                                     data[key] = numpy.array(array)
                             elif isinstance(value, list):
                                 array = []
                                 for ch in value:
                                     array.append(self.fp[ch][()])
                                 data[key] = numpy.array(array)
                     else:
                         grp = self.fp['Data']
                         for name in grp:
                             if isinstance(grp[name], h5py.Dataset):
                                 array = grp[name][()]
                             elif isinstance(grp[name], h5py.Group):
                                 array = []
                                 for ch in grp[name]:
                                     array.append(grp[name][ch][()])
                                 array = numpy.array(array)
                             else:
                                 log.warning('Unknown type: {}'.format(name))
                             if name in self.description:
                                 key = self.description[name]
                             else:
                                 key = name
                             data[key] = array
                     self.data = data
                     return
                 def getData(self):
                     if not self.isDateTimeInRange(self.startFileDatetime, self.startDate, self.endDate, self.startTime, self.endTime):
                         self.dataOut.flagNoData = True
                         self.blockIndex = self.blocksPerFile
                         self.dataOut.error = True     # TERMINA EL PROGRAMA
                         return
                     for attr in self.data:
                         if self.data[attr].ndim == 1:
                             setattr(self.dataOut, attr, self.data[attr][self.blockIndex])
                         else:
                             setattr(self.dataOut, attr, self.data[attr][:, self.blockIndex])
                     self.blockIndex += 1
                     if self.blockIndex == 1:
                         log.log("Block No. {}/{} -> {}".format(
                             self.blockIndex,
                             self.blocksPerFile,
                             self.dataOut.datatime.ctime()), self.name)
                     else:
                         log.log("Block No. {}/{} ".format(
                             self.blockIndex,
                             self.blocksPerFile),self.name)
                     if self.blockIndex == self.blocksPerFile:
                         self.setNextFile()
                     self.dataOut.flagNoData = False
                     return
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.blockIndex == self.blocksPerFile:
                         self.setNextFile()
                     self.getData()
                     return
             @MPDecorator
             class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                 The HDF5 file contains by default two groups Data and Metadata where
                 you can save any `dataOut` attribute specified by `dataList` and `metadataList`
                 parameters, data attributes are normaly time dependent where the metadata
                 are not.
                 It is possible to customize the structure of the HDF5 file with the
                 optional description parameter see the examples.
                 Parameters:
                 -----------
                 path : str
                     Path where files will be saved.
                 blocksPerFile : int
                     Number of blocks per file
                 metadataList : list
                     List of the dataOut attributes that will be saved as metadata
                 dataList : int
                     List of the dataOut attributes that will be saved as data
                 setType : bool
                     If True the name of the files corresponds to the timestamp of the data
                 description : dict, optional
                     Dictionary with the desired description of the HDF5 file
                 Examples
                 --------
                 desc = {
                     'data_output': {'winds': ['z', 'w', 'v']},
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'data_output': ['z', 'w', 'v'],
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 writer = proc_unit.addOperation(name='HDFWriter')
                 writer.addParameter(name='path', value='/path/to/file')
                 writer.addParameter(name='blocksPerFile', value='32')
                 writer.addParameter(name='metadataList', value='heightList,timeZone')
                 writer.addParameter(name='dataList',value='data_output,utctime')
                 # writer.addParameter(name='description',value=json.dumps(desc))
                 """
                 ext = ".hdf5"
                 optchar = "D"
                 filename = None
                 path = None
                 setFile = None
                 fp = None
+                ds = None
                 firsttime = True
                 #Configurations
                 blocksPerFile = None
                 blockIndex = None
                 dataOut = None                  #eval ??????
                 #Data Arrays
                 dataList = None
                 metadataList = None
                 currentDay = None
                 lastTime = None
                 timeZone = "ut"
                 hourLimit = 3
                 breakDays = True
                 def __init__(self):
                     Operation.__init__(self)
                     return
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def set_kwargs_obj(self, obj, **kwargs):
                     for key, value in kwargs.items():
                         setattr(obj, key, value)
                 def setup(self, path=None, blocksPerFile=10, metadataList=None, dataList=None, setType=None,
                             description={},timeZone = "ut",hourLimit = 3, breakDays=True, **kwargs):
                     self.path = path
                     self.blocksPerFile = blocksPerFile
                     self.metadataList = metadataList
                     self.dataList = [s.strip() for s in dataList]
                     self.setType = setType
                     self.description = description
                     self.timeZone = timeZone
                     self.hourLimit = hourLimit
                     self.breakDays = breakDays
                     self.set_kwargs(**kwargs)
                     if self.metadataList is None:
                         self.metadataList = self.dataOut.metadata_list
+                    self.metadataList = list(set(self.metadataList))
                     tableList = []
                     dsList = []
                     for i in range(len(self.dataList)):
                         dsDict = {}
                         if hasattr(self.dataOut, self.dataList[i]):
                             dataAux = getattr(self.dataOut, self.dataList[i])
                             dsDict['variable'] = self.dataList[i]
                         else:
                             log.warning('Attribute {} not found in dataOut'.format(self.dataList[i]),self.name)
                             continue
                         if dataAux is None:
                             continue
-                        elif isinstance(dataAux, (int, float, numpy.integer, numpy.float)):
+                        elif isinstance(dataAux, (int, float, numpy.integer, numpy.float_)):
                             dsDict['nDim'] = 0
                         else:
                             dsDict['nDim'] = len(dataAux.shape)
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                             dsDict['dtype'] = dataAux.dtype
                         dsList.append(dsDict)
+                    self.blockIndex = 0
                     self.dsList = dsList
                     self.currentDay = self.dataOut.datatime.date()
                 def timeFlag(self):
                     currentTime = self.dataOut.utctime
                     timeTuple = None
                     if self.timeZone == "lt":
                         timeTuple = time.localtime(currentTime)
                     else :
                         timeTuple = time.gmtime(currentTime)
                     dataDay = timeTuple.tm_yday
                     if self.lastTime is None:
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     # Si el dia es diferente o si la diferencia entre un
                     # dato y otro supera self.hourLimit
                     if (dataDay != self.currentDay) and self.breakDays:
                         self.currentDay = dataDay
                         return True
                     elif timeDiff > self.hourLimit*60*60:
                         self.lastTime = currentTime
                         return True
                     else:
                         self.lastTime = currentTime
                         return False
                 def run(self, dataOut, path, blocksPerFile=10, metadataList=None,
                         dataList=[], setType=None, description={}, **kwargs):
                     self.dataOut = dataOut
                     self.set_kwargs_obj(self.dataOut, **kwargs)
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description, **kwargs)
                         self.isConfig = True
                         self.setNextFile()
                     self.putData()
                     return
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     timeTuple = None
                     if self.timeZone == "lt":
                         timeTuple = time.localtime(self.dataOut.utctime)
                     elif self.timeZone == "ut":
                         timeTuple = time.gmtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     if os.path.exists(fullpath):
                         filesList = os.listdir(fullpath)
                         filesList = [k for k in filesList if k.startswith(self.optchar)]
                         if len(filesList) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber(filen[8:11]):
                                 setFile = int(filen[8:11]) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 setFile = -1
                         else:
                             setFile = -1 #inicializo mi contador de seteo
                     else:
                         os.makedirs(fullpath)
                         setFile = -1 #inicializo mi contador de seteo
                     if self.setType is None:
                         setFile += 1
                         file = '%s%4.4d%3.3d%03d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext)
                     else:
                         setFile = timeTuple.tm_hour*60+timeTuple.tm_min
                         file = '%s%4.4d%3.3d%04d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext)
                     self.filename = os.path.join(path, subfolder, file)
                 def getLabel(self, name, x=None):
                     if x is None:
                         if 'Data' in self.description:
                             data = self.description['Data']
                             if 'Metadata' in self.description:
                                 data.update(self.description['Metadata'])
                         else:
                             data = self.description
                         if name in data:
                             if isinstance(data[name], str):
                                 return data[name]
                             elif isinstance(data[name], list):
                                 return None
                             elif isinstance(data[name], dict):
                                 for key, value in data[name].items():
                                     return key
                         return name
                     else:
                         if 'Metadata' in self.description:
                             meta = self.description['Metadata']
                         else:
                             meta = self.description
                         if name in meta:
                             if isinstance(meta[name], list):
                                 return meta[name][x]
                             elif isinstance(meta[name], dict):
                                 for key, value in meta[name].items():
                                     return value[x]
                         if 'cspc' in name:
                             return 'pair{:02d}'.format(x)
                         else:
                             return 'channel{:02d}'.format(x)
                 def writeMetadata(self, fp):
                     if self.description:
                         if 'Metadata' in self.description:
                             grp = fp.create_group('Metadata')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Metadata')
                     for i in range(len(self.metadataList)):
                         if not hasattr(self.dataOut, self.metadataList[i]):
                             log.warning('Metadata: `{}` not found'.format(self.metadataList[i]), self.name)
                             continue
                         value = getattr(self.dataOut, self.metadataList[i])
                         if isinstance(value, bool):
                             if value is True:
                                 value = 1
                             else:
                                 value = 0
                         grp.create_dataset(self.getLabel(self.metadataList[i]), data=value)
                     return
                 def writeMetadata2(self, fp):
                     if self.description:
                         if 'Metadata' in self.description:
                             grp = fp.create_group('Metadata')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Metadata')
                     for i in range(len(self.metadataList)):
                         attribute = self.metadataList[i]
                         attr = attribute.split('.')
                         if len(attr) > 1:
                             if not hasattr(eval("self.dataOut."+attr[0]),attr[1]):
                                 log.warning('Metadata: {}.{} not found'.format(attr[0],attr[1]), self.name)
                                 continue
                             value = getattr(eval("self.dataOut."+attr[0]),attr[1])
                             if isinstance(value, bool):
                                 if value is True:
                                     value = 1
                                 else:
                                     value = 0
                             if isinstance(value,type(None)):
                                 log.warning("Invalid value detected, {} is None".format(attribute), self.name)
                                 value = 0
                             grp2 = None
                             if not 'Metadata/'+attr[0] in fp:
                                 grp2 = fp.create_group('Metadata/'+attr[0])
                             else:
                                 grp2 = fp['Metadata/'+attr[0]]
                             grp2.create_dataset(attr[1], data=value)
                         else:
                             if not hasattr(self.dataOut, attr[0] ):
                                 log.warning('Metadata: `{}` not found'.format(attribute), self.name)
                                 continue
                             value = getattr(self.dataOut, attr[0])
                             if isinstance(value, bool):
                                 if value is True:
                                     value = 1
                                 else:
                                     value = 0
                             if isinstance(value, type(None)):
                                 log.error("Value {} is None".format(attribute),self.name)
                             grp.create_dataset(self.getLabel(attribute), data=value)
                     return
                 def writeData(self, fp):
                     if self.description:
                         if 'Data' in self.description:
                             grp = fp.create_group('Data')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Data')
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
                                 (self.blocksPerFile,),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                         else:
                             label = self.getLabel(dsInfo['variable'])
                             if label is not None:
                                 sgrp = grp.create_group(label)
                             else:
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
                                     (self.blocksPerFile,) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                                 dtsets.append(ds)
                                 data.append((dsInfo['variable'], i))
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True
-                    self.blockIndex = 0
                     return
                 def putData(self):
                     if (self.blockIndex == self.blocksPerFile) or self.timeFlag():
                         self.closeFile()
                         self.setNextFile()
                         self.dataOut.flagNoData = False
                         self.blockIndex = 0
                     if self.blockIndex == 0:
                         #Setting HDF5 File
                         self.fp = h5py.File(self.filename, 'w')
                         #write metadata
                         self.writeMetadata2(self.fp)
                         #Write data
                         self.writeData(self.fp)
                         log.log('Block No. {}/{} --> {}'.format(self.blockIndex+1, self.blocksPerFile,self.dataOut.datatime.ctime()), self.name)
                     elif (self.blockIndex % 10 ==0):
                         log.log('Block No. {}/{} --> {}'.format(self.blockIndex+1, self.blocksPerFile,self.dataOut.datatime.ctime()), self.name)
                     else:
                         log.log('Block No. {}/{}'.format(self.blockIndex+1, self.blocksPerFile), self.name)
                     for i, ds in enumerate(self.ds):
                         attr, ch = self.data[i]
                         if ch == -1:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)
                         else:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)[ch]
                     self.blockIndex += 1
                     self.fp.flush()
                     self.dataOut.flagNoData = True
                 def closeFile(self):
                     if self.blockIndex != self.blocksPerFile:
                         for ds in self.ds:
                             ds.resize(self.blockIndex, axis=0)
                     if self.fp:
                         self.fp.flush()
                         self.fp.close()
                 def close(self):
                     self.closeFile()

schainpy/model/proc/jroproc_parameters.py +593 -247

             import numpy
             import math
             from scipy import optimize, interpolate, signal, stats, ndimage
             from scipy.fftpack import fft
             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 time
             from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
             from .jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import Parameters, hildebrand_sekhon
             from schainpy.model.data.jrodata import Spectra
             from numpy import asarray as ar,exp
             from scipy.optimize import fmin, curve_fit
             from schainpy.utils import log
             import warnings
             from numpy import NaN
             from scipy.optimize.optimize import OptimizeWarning
             warnings.filterwarnings('ignore')
+            import json
             import os
             import csv
             from scipy import signal
             import matplotlib.pyplot as plt
             SPEED_OF_LIGHT = 299792458
             '''solving pickling issue'''
             def _pickle_method(method):
                 func_name = method.__func__.__name__
                 obj = method.__self__
                 cls = method.__self__.__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):
                 METHODS = {}
                 nSeconds = None
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Parameters()
                     self.setupReq = False #Agregar a todas las unidades de proc
                 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.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.ipp = self.dataIn.ipp
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.deltaHeight = self.dataIn.deltaHeight
                     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.dataIn.nProfiles
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     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 = self.dataIn.nIncohInt
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.timeInterval1 = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.codeList = self.dataIn.codeList
                     self.dataOut.azimuthList = self.dataIn.azimuthList
                     self.dataOut.elevationList = self.dataIn.elevationList
                     self.dataOut.runNextUnit = self.dataIn.runNextUnit
                 def run(self, runNextUnit=0):
                     self.dataIn.runNextUnit = runNextUnit
                     #----------------------    Voltage Data    ---------------------------
                     try:
                         intype = self.dataIn.type.decode("utf-8")
                         self.dataIn.type = intype
                     except:
                         pass
                     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
                         if hasattr(self.dataIn, 'dataPP_POW'):
                             self.dataOut.dataPP_POW = self.dataIn.dataPP_POW
                         if hasattr(self.dataIn, 'dataPP_POWER'):
                             self.dataOut.dataPP_POWER = self.dataIn.dataPP_POWER
                         if hasattr(self.dataIn, 'dataPP_DOP'):
                             self.dataOut.dataPP_DOP = self.dataIn.dataPP_DOP
                         if hasattr(self.dataIn, 'dataPP_SNR'):
                             self.dataOut.dataPP_SNR = self.dataIn.dataPP_SNR
                         if hasattr(self.dataIn, 'dataPP_WIDTH'):
                             self.dataOut.dataPP_WIDTH = self.dataIn.dataPP_WIDTH
                         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.data_outlier = self.dataIn.data_outlier
                         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.flagProfilesByRange = self.dataIn.flagProfilesByRange
                         self.dataOut.nProfilesByRange = self.dataIn.nProfilesByRange
                         self.dataOut.deltaHeight = self.dataIn.deltaHeight
                         self.dataOut.abscissaList = self.dataIn.getVelRange(1)
                         self.dataOut.spc_noise = self.dataIn.getNoise()
                         self.dataOut.spc_range = (self.dataIn.getFreqRange(1) , self.dataIn.getAcfRange(1) , self.dataIn.getVelRange(1))
                         # self.dataOut.normFactor = self.dataIn.normFactor
                         if hasattr(self.dataIn, 'channelList'):
                             self.dataOut.channelList = self.dataIn.channelList
                         if hasattr(self.dataIn, 'pairsList'):
                             self.dataOut.pairsList = self.dataIn.pairsList
                             self.dataOut.groupList = self.dataIn.pairsList
                         self.dataOut.flagNoData = False
                         self.dataOut.noise_estimation = self.dataIn.noise_estimation
                         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.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                         self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
                         self.dataOut.flagNoData = False
                         if isinstance(self.dataIn.nIncohInt,numpy.ndarray):
                             nch, nheis = self.dataIn.nIncohInt.shape
                             if nch != self.dataIn.nChannels:
                                 aux = numpy.repeat(self.dataIn.nIncohInt, self.dataIn.nChannels, axis=0)
                                 self.dataOut.nIncohInt = aux
                         return True
                     self.__updateObjFromInput()
                     self.dataOut.utctimeInit = self.dataIn.utctime
                     self.dataOut.paramInterval = self.dataIn.timeInterval
                     return
             def target(tups):
                 obj, args = tups
                 return obj.FitGau(args)
             class RemoveWideGC(Operation):
                 ''' This class remove the wide clutter and replace it with a simple interpolation points
                     This mainly applies to CLAIRE radar
                     ClutterWidth :    Width to look for the clutter peak
                     Input:
                     self.dataOut.data_pre :        SPC and CSPC
                     self.dataOut.spc_range :       To select wind and rainfall velocities
                     Affected:
                     self.dataOut.data_pre :        It is used for the new SPC and CSPC ranges of wind
                     Written by D. Scipión 25.02.2021
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                     self.i = 0
                     self.ich = 0
                     self.ir = 0
                 def run(self, dataOut, ClutterWidth=2.5):
                     self.spc = dataOut.data_pre[0].copy()
                     self.spc_out = dataOut.data_pre[0].copy()
                     self.Num_Chn = self.spc.shape[0]
                     self.Num_Hei = self.spc.shape[2]
                     VelRange = dataOut.spc_range[2][:-1]
                     dv = VelRange[1]-VelRange[0]
                     # Find the velocities that corresponds to zero
                     gc_values = numpy.squeeze(numpy.where(numpy.abs(VelRange) <= ClutterWidth))
                     # Removing novalid data from the spectra
                     for ich in range(self.Num_Chn) :
                         for ir in range(self.Num_Hei) :
                             # Estimate the noise at each range
                             HSn = hildebrand_sekhon(self.spc[ich,:,ir],dataOut.nIncohInt)
                             # Removing the noise floor at each range
                             novalid = numpy.where(self.spc[ich,:,ir] < HSn)
                             self.spc[ich,novalid,ir] = HSn
                             junk = numpy.append(numpy.insert(numpy.squeeze(self.spc[ich,gc_values,ir]),0,HSn),HSn)
                             j1index = numpy.squeeze(numpy.where(numpy.diff(junk)>0))
                             j2index = numpy.squeeze(numpy.where(numpy.diff(junk)<0))
                             if ((numpy.size(j1index)<=1) | (numpy.size(j2index)<=1)) :
                                 continue
                             junk3 = numpy.squeeze(numpy.diff(j1index))
                             junk4 = numpy.squeeze(numpy.diff(j2index))
                             valleyindex = j2index[numpy.where(junk4>1)]
                             peakindex = j1index[numpy.where(junk3>1)]
                             isvalid = numpy.squeeze(numpy.where(numpy.abs(VelRange[gc_values[peakindex]]) <= 2.5*dv))
                             if numpy.size(isvalid) == 0 :
                                 continue
                             if numpy.size(isvalid) >1 :
                                 vindex = numpy.argmax(self.spc[ich,gc_values[peakindex[isvalid]],ir])
                                 isvalid = isvalid[vindex]
                             # clutter peak
                             gcpeak = peakindex[isvalid]
                             vl = numpy.where(valleyindex < gcpeak)
                             if numpy.size(vl) == 0:
                                 continue
                             gcvl = valleyindex[vl[0][-1]]
                             vr = numpy.where(valleyindex > gcpeak)
                             if numpy.size(vr) == 0:
                                 continue
                             gcvr = valleyindex[vr[0][0]]
                             # Removing the clutter
                             interpindex = numpy.array([gc_values[gcvl], gc_values[gcvr]])
                             gcindex = gc_values[gcvl+1:gcvr-1]
                             self.spc_out[ich,gcindex,ir] = numpy.interp(VelRange[gcindex],VelRange[interpindex],self.spc[ich,interpindex,ir])
                     dataOut.data_pre[0] = self.spc_out
                     return dataOut
             class SpectralFilters(Operation):
                 ''' This class allows to replace the novalid values with noise for each channel
                     This applies to CLAIRE RADAR
                     PositiveLimit :    RightLimit of novalid data
                     NegativeLimit :    LeftLimit of novalid data
                     Input:
                     self.dataOut.data_pre :        SPC and CSPC
                     self.dataOut.spc_range :       To select wind and rainfall velocities
                     Affected:
                     self.dataOut.data_pre :        It is used for the new SPC and CSPC ranges of wind
                     Written by D. Scipión 29.01.2021
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                     self.i = 0
                 def run(self, dataOut, ):
                     self.spc = dataOut.data_pre[0].copy()
                     self.Num_Chn = self.spc.shape[0]
                     VelRange = dataOut.spc_range[2]
                     # novalid corresponds to data within the Negative and PositiveLimit
                     # Removing novalid data from the spectra
                     for i in range(self.Num_Chn):
                         self.spc[i,novalid,:] = dataOut.noise[i]
                     dataOut.data_pre[0] = self.spc
                     return dataOut
             class GaussianFit(Operation):
                 '''
                     Function that fit of one and two generalized gaussians (gg) based
                     on the PSD shape across an "power band" identified from a cumsum of
                     the measured spectrum - noise.
                     Input:
                         self.dataOut.data_pre    :    SelfSpectra
                     Output:
                         self.dataOut.SPCparam :    SPC_ch1, SPC_ch2
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                     self.i=0
                 def run(self, dataOut, SNRdBlimit=-9, method='generalized'):
                     """This routine will find a couple of generalized Gaussians to a power spectrum
                     methods: generalized, squared
                     input: spc
                     output:
                         noise, amplitude0,shift0,width0,p0,Amplitude1,shift1,width1,p1
                     """
                     print ('Entering ',method,' double Gaussian fit')
                     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]
                     start_time = time.time()
                     pool = Pool(processes=self.Num_Chn)
                     args = [(dataOut.spc_range[2], ich, dataOut.spc_noise[ich], dataOut.nIncohInt, SNRdBlimit) for ich in range(self.Num_Chn)]
                     objs = [self for __ in range(self.Num_Chn)]
                     attrs = list(zip(objs, args))
                     DGauFitParam = pool.map(target, attrs)
                     # Parameters:
                     # 0. Noise, 1. Amplitude, 2. Shift, 3. Width 4. Power
                     dataOut.DGauFitParams = numpy.asarray(DGauFitParam)
                     # Double Gaussian Curves
                     gau0 = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
                     gau0[:] = numpy.NaN
                     gau1 = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
                     gau1[:] = numpy.NaN
                     x_mtr = numpy.transpose(numpy.tile(dataOut.getVelRange(1)[:-1], (self.Num_Hei,1)))
                     for iCh in range(self.Num_Chn):
                         N0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][0,:,0]] * self.Num_Bin))
                         N1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][0,:,1]] * self.Num_Bin))
                         A0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][1,:,0]] * self.Num_Bin))
                         A1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][1,:,1]] * self.Num_Bin))
                         v0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][2,:,0]] * self.Num_Bin))
                         v1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][2,:,1]] * self.Num_Bin))
                         s0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][3,:,0]] * self.Num_Bin))
                         s1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][3,:,1]] * self.Num_Bin))
                         if method == 'generalized':
                             p0 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][4,:,0]] * self.Num_Bin))
                             p1 = numpy.transpose(numpy.transpose([dataOut.DGauFitParams[iCh][4,:,1]] * self.Num_Bin))
                         elif method == 'squared':
                             p0 = 2.
                             p1 = 2.
                         gau0[iCh] = A0*numpy.exp(-0.5*numpy.abs((x_mtr-v0)/s0)**p0)+N0
                         gau1[iCh] = A1*numpy.exp(-0.5*numpy.abs((x_mtr-v1)/s1)**p1)+N1
                     dataOut.GaussFit0 = gau0
                     dataOut.GaussFit1 = gau1
                     print('Leaving ',method ,' double Gaussian fit')
                     return dataOut
                 def FitGau(self, X):
                     # print('Entering FitGau')
                     # Assigning the variables
                     Vrange, ch, wnoise, num_intg, SNRlimit = X
                     # Noise Limits
                     noisebl = wnoise * 0.9
                     noisebh = wnoise * 1.1
                     # Radar Velocity
                     Va = max(Vrange)
                     deltav = Vrange[1] - Vrange[0]
                     x = numpy.arange(self.Num_Bin)
                     # print ('stop 0')
                     # 5 parameters, 2 Gaussians
                     DGauFitParam = numpy.zeros([5, self.Num_Hei,2])
                     DGauFitParam[:] = numpy.NaN
                     # SPCparam = []
                     # SPC_ch1 = numpy.zeros([self.Num_Bin,self.Num_Hei])
                     # SPC_ch2 = numpy.zeros([self.Num_Bin,self.Num_Hei])
                     # SPC_ch1[:] = 0 #numpy.NaN
                     # SPC_ch2[:] = 0 #numpy.NaN
                     # print ('stop 1')
                     for ht in range(self.Num_Hei):
                         # print (ht)
                         # print ('stop 2')
                         # Spectra at each range
                         spc =  numpy.asarray(self.spc)[ch,:,ht]
                         snr = ( spc.mean() - wnoise ) / wnoise
                         snrdB = 10.*numpy.log10(snr)
                         #print ('stop 3')
                         if snrdB < SNRlimit :
                             # snr = numpy.NaN
                             # SPC_ch1[:,ht] = 0#numpy.NaN
                             # SPC_ch1[:,ht] = 0#numpy.NaN
                             # SPCparam = (SPC_ch1,SPC_ch2)
                             # print ('SNR less than SNRth')
                             continue
                         # wnoise = hildebrand_sekhon(spc,num_intg)
                         # print ('stop 2.01')
                         #############################################
                         # normalizing spc and noise
                         # This part differs from gg1
                         # spc_norm_max = max(spc) #commented by D. Scipión 19.03.2021
                         #spc = spc / spc_norm_max
                         # pnoise = pnoise #/ spc_norm_max #commented by D. Scipión 19.03.2021
                         #############################################
                         # print ('stop 2.1')
                         fatspectra=1.0
                         # noise per channel.... we might want to use the noise at each range
                         # wnoise = noise_ #/ spc_norm_max #commented by D. Scipión 19.03.2021
                             #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 # signal
                         # print ('stop 2.2')
                         minx = numpy.argmin(spc)
                         #spcs=spc.copy()
                         spcs = numpy.roll(spc,-minx)
                         cum = numpy.cumsum(spcs)
                         # tot_noise = wnoise * self.Num_Bin  #64;
                         # print ('stop 2.3')
                         # snr = sum(spcs) / tot_noise
                         # snrdB = 10.*numpy.log10(snr)
                         #print ('stop 3')
                         # if snrdB < SNRlimit :
                             # snr = numpy.NaN
                             # SPC_ch1[:,ht] = 0#numpy.NaN
                             # SPC_ch1[:,ht] = 0#numpy.NaN
                             # SPCparam = (SPC_ch1,SPC_ch2)
                             # print ('SNR less than SNRth')
                             # continue
                         #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
                         # print ('stop 4')
                         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])
                         # print ('stop 5')
                         if len(powerindex) < 1:# case for powerindex 0
                             # print ('powerindex < 1')
                             continue
                         powerlo = powerindex[0]
                         powerhi = powerindex[-1]
                         powerwidth = powerhi-powerlo
                         if powerwidth <= 1:
                             # print('powerwidth <= 1')
                             continue
                         # print ('stop 6')
                         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)]
                         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)
                         # print ('stop 7.1')
                         # print (bnds)
                         chiSq1=lsq1[1]
                         # print ('stop 8')
                         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)
                         # print ('stop 9')
                         '''    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))
                         # print ('stop 10')
                         lsq2 = fmin_l_bfgs_b( self.misfit2 , state0 , args=(y_data,x,num_intg) , bounds=bnds , approx_grad=True )
                         # print ('stop 11')
                         chiSq2 = lsq2[1]
                         # print ('stop 12')
                         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)
                         # print ('stop 13')
                         if snrdB>-12: # 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 ('stop 14')
                         shift0 = lsq2[0][0]
                         vel0 = Vrange[0] + shift0 * deltav
                         shift1 = lsq2[0][4]
                         # vel1=Vrange[0] + shift1 * deltav
                         # max_vel = 1.0
                         # Va = max(Vrange)
                         # deltav = Vrange[1]-Vrange[0]
                         # print ('stop 15')
                         #first peak will be 0, second peak will be 1
                         # if vel0 > -1.0 and vel0 < max_vel : #first peak is in the correct range # Commented by D.Scipión 19.03.2021
                         if vel0 > -Va and vel0 < Va : #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.05: # in case the peak is noise
                             shift0,width0,Amplitude0,p0 = 4*[numpy.NaN]
                         if Amplitude1<0.05:
                             shift1,width1,Amplitude1,p1 = 4*[numpy.NaN]
                         # print ('stop 16 ')
                         # 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)
                         # SPCparam = (SPC_ch1,SPC_ch2)
                         DGauFitParam[0,ht,0] = noise
                         DGauFitParam[0,ht,1] = noise
                         DGauFitParam[1,ht,0] = Amplitude0
                         DGauFitParam[1,ht,1] = Amplitude1
                         DGauFitParam[2,ht,0] = Vrange[0] + shift0 * deltav
                         DGauFitParam[2,ht,1] = Vrange[0] + shift1 * deltav
                         DGauFitParam[3,ht,0] = width0 * deltav
                         DGauFitParam[3,ht,1] = width1 * deltav
                         DGauFitParam[4,ht,0] = p0
                         DGauFitParam[4,ht,1] = p1
                     return DGauFitParam
                 def y_model1(self,x,state):
                     shift0, width0, amplitude0, power0, noise = state
                     model0 = amplitude0*numpy.exp(-0.5*abs((x - shift0)/width0)**power0)
                     model0u = amplitude0*numpy.exp(-0.5*abs((x - shift0 - self.Num_Bin)/width0)**power0)
                     model0d = amplitude0*numpy.exp(-0.5*abs((x - shift0 + self.Num_Bin)/width0)**power0)
                     return model0 + model0u + model0d + noise
                 def y_model2(self,x,state): #Equation for two generalized Gaussians with Nyquist
                     shift0, width0, amplitude0, power0, shift1, width1, amplitude1, power1, noise = state
                     model0 = amplitude0*numpy.exp(-0.5*abs((x-shift0)/width0)**power0)
                     model0u = amplitude0*numpy.exp(-0.5*abs((x - shift0 - self.Num_Bin)/width0)**power0)
                     model0d = amplitude0*numpy.exp(-0.5*abs((x - shift0 + self.Num_Bin)/width0)**power0)
                     model1 = amplitude1*numpy.exp(-0.5*abs((x - shift1)/width1)**power1)
                     model1u = amplitude1*numpy.exp(-0.5*abs((x - shift1 - self.Num_Bin)/width1)**power1)
                     model1d = amplitude1*numpy.exp(-0.5*abs((x - shift1 + self.Num_Bin)/width1)**power1)
                     return model0 + model0u + model0d + model1 + model1u + model1d + noise
                 def misfit1(self,state,y_data,x,num_intg): # This function compares how close real data is with the model data, the close it is, the better it is.
                     return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model1(x,state)))**2)#/(64-5.) # /(64-5.) can be commented
                 def misfit2(self,state,y_data,x,num_intg):
                     return num_intg*sum((numpy.log(y_data)-numpy.log(self.y_model2(x,state)))**2)#/(64-9.)
             class Oblique_Gauss_Fit(Operation):
                 '''
                 Written by R. Flores
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                 def Gauss_fit(self,spc,x,nGauss):
                     def gaussian(x, a, b, c, d):
                         val = a * numpy.exp(-(x - b)**2 / (2*c**2)) + d
                         return val
                     if nGauss == 'first':
                         spc_1_aux = numpy.copy(spc[:numpy.argmax(spc)+1])
                         spc_2_aux = numpy.flip(spc_1_aux)
                         spc_3_aux = numpy.concatenate((spc_1_aux,spc_2_aux[1:]))
                         len_dif = len(x)-len(spc_3_aux)
                         spc_zeros = numpy.ones(len_dif)*spc_1_aux[0]
                         spc_new = numpy.concatenate((spc_3_aux,spc_zeros))
                         y = spc_new
                     elif nGauss == 'second':
                         y = spc
                     # estimate starting values from the data
                     a = y.max()
                     b = x[numpy.argmax(y)]
                     if nGauss == 'first':
                         c = 1.#b#b#numpy.std(spc)
                     elif nGauss == 'second':
                         c = b
                     else:
                         print("ERROR")
                     d = numpy.mean(y[-100:])
                     # define a least squares function to optimize
                     def minfunc(params):
                         return sum((y-gaussian(x,params[0],params[1],params[2],params[3]))**2)
                     # fit
                     popt = fmin(minfunc,[a,b,c,d],disp=False)
                     #popt,fopt,niter,funcalls = fmin(minfunc,[a,b,c,d])
                     return gaussian(x, popt[0], popt[1], popt[2], popt[3]), popt[0], popt[1], popt[2], popt[3]
                 def Gauss_fit_2(self,spc,x,nGauss):
                     def gaussian(x, a, b, c, d):
                         val = a * numpy.exp(-(x - b)**2 / (2*c**2)) + d
                         return val
                     if nGauss == 'first':
                         spc_1_aux = numpy.copy(spc[:numpy.argmax(spc)+1])
                         spc_2_aux = numpy.flip(spc_1_aux)
                         spc_3_aux = numpy.concatenate((spc_1_aux,spc_2_aux[1:]))
                         len_dif = len(x)-len(spc_3_aux)
                         spc_zeros = numpy.ones(len_dif)*spc_1_aux[0]
                         spc_new = numpy.concatenate((spc_3_aux,spc_zeros))
                         y = spc_new
                     elif nGauss == 'second':
                         y = spc
                     # estimate starting values from the data
                     a = y.max()
                     b = x[numpy.argmax(y)]
                     if nGauss == 'first':
                         c = 1.#b#b#numpy.std(spc)
                     elif nGauss == 'second':
                         c = b
                     else:
                         print("ERROR")
                     d = numpy.mean(y[-100:])
                     popt,pcov = curve_fit(gaussian,x,y,p0=[a,b,c,d])
                     return gaussian(x, popt[0], popt[1], popt[2], popt[3]),popt[0], popt[1], popt[2], popt[3]
                 def Double_Gauss_fit(self,spc,x,A1,B1,C1,A2,B2,C2,D):
                     def double_gaussian(x, a1, b1, c1, a2, b2, c2, d):
                         val = a1 * numpy.exp(-(x - b1)**2 / (2*c1**2)) + a2 * numpy.exp(-(x - b2)**2 / (2*c2**2)) + d
                         return val
                     y = spc
                     # estimate starting values from the data
                     a1 = A1
                     b1 = B1
                     c1 = C1#numpy.std(spc)
                     a2 = A2#y.max()
                     b2 = B2#x[numpy.argmax(y)]
                     c2 = C2#numpy.std(spc)
                     d = D
                     # define a least squares function to optimize
                     def minfunc(params):
                         return sum((y-double_gaussian(x,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))**2)
                     # fit
                     popt = fmin(minfunc,[a1,b1,c1,a2,b2,c2,d],disp=False)
                     return double_gaussian(x, popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]), popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                 def Double_Gauss_fit_2(self,spc,x,A1,B1,C1,A2,B2,C2,D):
                     def double_gaussian(x, a1, b1, c1, a2, b2, c2, d):
                         val = a1 * numpy.exp(-(x - b1)**2 / (2*c1**2)) + a2 * numpy.exp(-(x - b2)**2 / (2*c2**2)) + d
                         return val
                     y = spc
                     # estimate starting values from the data
                     a1 = A1
                     b1 = B1
                     c1 = C1#numpy.std(spc)
                     a2 = A2#y.max()
                     b2 = B2#x[numpy.argmax(y)]
                     c2 = C2#numpy.std(spc)
                     d = D
                     # fit
                     popt,pcov = curve_fit(double_gaussian,x,y,p0=[a1,b1,c1,a2,b2,c2,d])
                     error = numpy.sqrt(numpy.diag(pcov))
                     return popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6], error[0], error[1], error[2], error[3], error[4], error[5], error[6]
                 def windowing_double(self,spc,x,A1,B1,C1,A2,B2,C2,D):
                     from scipy.optimize import curve_fit,fmin
                     def R_gaussian(x, a, b, c):
                             N = int(numpy.shape(x)[0])
                             val = a * numpy.exp(-((x)*c*2*2*numpy.pi)**2 / (2))* numpy.exp(1.j*b*x*4*numpy.pi)
                             return val
                     def T(x,N):
                         T = 1-abs(x)/N
                         return T
                     def R_T_spc_fun(x, a1, b1, c1, a2, b2, c2, d):
                         N = int(numpy.shape(x)[0])
                         x_max = x[-1]
                         x_pos = x[1600:]
                         x_neg = x[:1600]
                         R_T_neg_1 = R_gaussian(x, a1, b1, c1)[:1600]*T(x_neg,-x[0])
                         R_T_pos_1 = R_gaussian(x, a1, b1, c1)[1600:]*T(x_pos,x[-1])
                         R_T_sum_1 = R_T_pos_1 + R_T_neg_1
                         R_T_spc_1 = numpy.fft.fft(R_T_sum_1).real
                         R_T_spc_1 = numpy.fft.fftshift(R_T_spc_1)
                         max_val_1 = numpy.max(R_T_spc_1)
                         R_T_spc_1 = R_T_spc_1*a1/max_val_1
                         R_T_neg_2 = R_gaussian(x, a2, b2, c2)[:1600]*T(x_neg,-x[0])
                         R_T_pos_2 = R_gaussian(x, a2, b2, c2)[1600:]*T(x_pos,x[-1])
                         R_T_sum_2 = R_T_pos_2 + R_T_neg_2
                         R_T_spc_2 = numpy.fft.fft(R_T_sum_2).real
                         R_T_spc_2 = numpy.fft.fftshift(R_T_spc_2)
                         max_val_2 = numpy.max(R_T_spc_2)
                         R_T_spc_2 = R_T_spc_2*a2/max_val_2
                         R_T_d = d*numpy.fft.fftshift(signal.unit_impulse(N))
                         R_T_d_neg = R_T_d[:1600]*T(x_neg,-x[0])
                         R_T_d_pos = R_T_d[1600:]*T(x_pos,x[-1])
                         R_T_d_sum = R_T_d_pos + R_T_d_neg
                         R_T_spc_3 = numpy.fft.fft(R_T_d_sum).real
                         R_T_spc_3 = numpy.fft.fftshift(R_T_spc_3)
                         R_T_final = R_T_spc_1 + R_T_spc_2 + R_T_spc_3
                         return R_T_final
                     y = spc#gaussian(x, a, meanY, sigmaY) + a*0.1*numpy.random.normal(0, 1, size=len(x))
                     from scipy.stats import norm
                     mean,std=norm.fit(spc)
                     # estimate starting values from the data
                     a1 = A1
                     b1 = B1
                     c1 = C1#numpy.std(spc)
                     a2 = A2#y.max()
                     b2 = B2#x[numpy.argmax(y)]
                     c2 = C2#numpy.std(spc)
                     d = D
                     ippSeconds = 250*20*1.e-6/3
                     x_t = ippSeconds * (numpy.arange(1600) -1600 / 2.)
                     x_t = numpy.linspace(x_t[0],x_t[-1],3200)
                     x_freq = numpy.fft.fftfreq(1600,d=ippSeconds)
                     x_freq = numpy.fft.fftshift(x_freq)
                     # define a least squares function to optimize
                     def minfunc(params):
                         return sum((y-R_T_spc_fun(x_t,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))**2/1)#y**2)
                     # fit
                     popt_full = fmin(minfunc,[a1,b1,c1,a2,b2,c2,d],full_output=True)
                     popt = popt_full[0]
                     return popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                 def Double_Gauss_fit_weight(self,spc,x,A1,B1,C1,A2,B2,C2,D):
                     from scipy.optimize import curve_fit,fmin
                     def double_gaussian(x, a1, b1, c1, a2, b2, c2, d):
                         val = a1 * numpy.exp(-(x - b1)**2 / (2*c1**2)) + a2 * numpy.exp(-(x - b2)**2 / (2*c2**2)) + d
                         return val
                     y = spc
                     from scipy.stats import norm
                     mean,std=norm.fit(spc)
                     # estimate starting values from the data
                     a1 = A1
                     b1 = B1
                     c1 = C1#numpy.std(spc)
                     a2 = A2#y.max()
                     b2 = B2#x[numpy.argmax(y)]
                     c2 = C2#numpy.std(spc)
                     d = D
                     y_clean = signal.medfilt(y)
                     # define a least squares function to optimize
                     def minfunc(params):
                         return sum((y-double_gaussian(x,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))**2/(y_clean**2/1))
                     # fit
                     popt_full = fmin(minfunc,[a1,b1,c1,a2,b2,c2,d], disp =False, full_output=True)
                     #print("nIter", popt_full[2])
                     popt = popt_full[0]
                     #popt,pcov = curve_fit(double_gaussian,x,y,p0=[a1,b1,c1,a2,b2,c2,d])
                     #return double_gaussian(x, popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]), popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                     return popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                 def DH_mode(self,spectra,VelRange):
                     from scipy.optimize import curve_fit
                     def double_gauss(x, a1,b1,c1, a2,b2,c2, d):
                         val = a1 * numpy.exp(-(x - b1)**2 / (2*c1**2)) + a2 * numpy.exp(-(x - b2)**2 / (2*c2**2)) + d
                         return val
                     spec = (spectra.copy()).flatten()
                     amp=spec.max()
                     params=numpy.array([amp,-400,30,amp/4,-200,150,1.0e7])
                     #try:
                     popt,pcov=curve_fit(double_gauss, VelRange, spec, p0=params,bounds=([0,-460,0,0,-400,120,0],[numpy.inf,-340,50,numpy.inf,0,250,numpy.inf]))
                     error = numpy.sqrt(numpy.diag(pcov))
                         #doppler_2=popt[4]
                         #err_2 = numpy.sqrt(pcov[4][4])
                     #except:
                         #pass
                         #doppler_2=numpy.NAN
                         #err_2 = numpy.NAN
                     #return doppler_2, err_2
                     return popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6], error[0], error[1], error[2], error[3], error[4], error[5], error[6]
                 def Tri_Marco(self,spc,freq,a1,b1,c1,a2,b2,c2,d):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     def tri_gaussian(x, a1, b1, c1, a2, b2, c2, a3, b3, c3, d):
                         z1 = (x-b1)/c1
                         z2 = (x-b2)/c2
                         z3 = (x-b3)/c3
                         val = a1 * numpy.exp(-z1**2/2) + a2 * numpy.exp(-z2**2/2) + a3 * numpy.exp(-z3**2/2) + d
                         return val
                     from scipy.signal import medfilt
                     Nincoh = 20
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     c1 = abs(c1)
                     c2 = abs(c2)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-tri_gaussian(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9]))/spcm
                     # fit
                     bounds=([0,-numpy.inf,0,0,-numpy.inf,0,0,0,0,0],[numpy.inf,-100,numpy.inf,numpy.inf,0,numpy.inf,numpy.inf,600,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,spc_max]
                     #print(a1,b1,c1,a2,b2,c2,d)
                     popt = least_squares(lsq_func,[a1,b1,c1,a2,b2,c2,a2/4,-b1,c1,d],x_scale=params_scale,bounds=bounds)
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     A2f = popt.x[3]; B2f = popt.x[4]; C2f = popt.x[5]
                     A3f = popt.x[6]; B3f = popt.x[7]; C3f = popt.x[8]
                     Df = popt.x[9]
                     return A1f, B1f, C1f, A2f, B2f, C2f, Df
                 def Tri_Marco(self,spc,freq,a1,b1,c1,a2,b2,c2,d):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     def duo_gaussian(x, a1, b1, c1, a2, b2, c2, d):
                         z1 = (x-b1)/c1
                         z2 = (x-b2)/c2
                         #z3 = (x-b3)/c3
                         val = a1 * numpy.exp(-z1**2/2) + a2 * numpy.exp(-z2**2/2) + d
                         return val
                     from scipy.signal import medfilt
                     Nincoh = 20
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     c1 = abs(c1)
                     c2 = abs(c2)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-tri_gaussian(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))/spcm
                     # fit
                     bounds=([0,-numpy.inf,0,0,-numpy.inf,0,0],[numpy.inf,-100,numpy.inf,numpy.inf,0,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,spc_max]
                     popt = least_squares(lsq_func,[a1,b1,c1,a2,b2,c2,d],x_scale=params_scale,bounds=bounds)
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     A2f = popt.x[3]; B2f = popt.x[4]; C2f = popt.x[5]
                     #A3f = popt.x[6]; B3f = popt.x[7]; C3f = popt.x[8]
                     Df = popt.x[9]
                     return A1f, B1f, C1f, A2f, B2f, C2f, Df
                 def double_gaussian_skew(self,x, a1, b1, c1, a2, b2, c2, k2, d):
                     z1 = (x-b1)/c1
                     z2 = (x-b2)/c2
                     h2 = 1-k2*z2
                     h2[h2<0] = 0
                     y2 = -1/k2*numpy.log(h2)
                     val = a1 * numpy.exp(-z1**2/2) + a2 * numpy.exp(-y2**2/2)/(1-k2*z2) + d
                     return val
                 def gaussian(self, x, a, b, c, d):
                     z = (x-b)/c
                     val = a * numpy.exp(-z**2/2) + d
                     return val
                 def double_gaussian(self, x, a1, b1, c1, a2, b2, c2, d):
                     z1 = (x-b1)/c1
                     z2 = (x-b2)/c2
                     val = a1 * numpy.exp(-z1**2/2) + a2 * numpy.exp(-z2**2/2) + d
                     return val
                 def double_gaussian_double_skew(self,x, a1, b1, c1, k1, a2, b2, c2, k2, d):
                     z1 = (x-b1)/c1
                     h1 = 1-k1*z1
                     h1[h1<0] = 0
                     y1 = -1/k1*numpy.log(h1)
                     z2 = (x-b2)/c2
                     h2 = 1-k2*z2
                     h2[h2<0] = 0
                     y2 = -1/k2*numpy.log(h2)
                     val = a1 * numpy.exp(-y1**2/2)/(1-k1*z1) + a2 * numpy.exp(-y2**2/2)/(1-k2*z2) + d
                     return val
                 def gaussian_skew(self,x, a2, b2, c2, k2, d):
                     z2 = (x-b2)/c2
                     h2 = 1-k2*z2
                     h2[h2<0] = 0
                     y2 = -1/k2*numpy.log(h2)
                     val = a2 * numpy.exp(-y2**2/2)/(1-k2*z2) + d
                     return val
                 def triple_gaussian_skew(self,x, a1, b1, c1, a2, b2, c2, k2, a3, b3, c3, k3, d):
                     z1 = (x-b1)/c1
                     z2 = (x-b2)/c2
                     z3 = (x-b3)/c3
                     h2 = 1-k2*z2
                     h2[h2<0] = 0
                     y2 = -1/k2*numpy.log(h2)
                     h3 = 1-k3*z3
                     h3[h3<0] = 0
                     y3 = -1/k3*numpy.log(h3)
                     val = a1 * numpy.exp(-z1**2/2) + a2 * numpy.exp(-y2**2/2)/(1-k2*z2) + a3 * numpy.exp(-y3**2/2)/(1-k3*z3) + d
                     return val
                 def Double_Gauss_Skew_fit_weight_bound_no_inputs(self,spc,freq):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = 20
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.double_gaussian_skew(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7]))/spcm
                     # fit
                     bounds=([0,-numpy.inf,0,0,-400,0,0,0],[numpy.inf,-340,numpy.inf,numpy.inf,0,numpy.inf,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,1,spc_max]
                     x0_value = numpy.array([spc_max,-400,30,spc_max/4,-200,150,1,1.0e7])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     A2f = popt.x[3]; B2f = popt.x[4]; C2f = popt.x[5]; K2f = popt.x[6]
                     Df = popt.x[7]
                     aux = self.gaussian_skew(freq, A2f, B2f, C2f, K2f, Df)
                     doppler = freq[numpy.argmax(aux)]
                     return A1f, B1f, C1f, A2f, B2f, C2f, K2f, Df, doppler
                 def Double_Gauss_Double_Skew_fit_weight_bound_no_inputs(self,spc,freq,Nincoh,hei):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     #from scipy.signal import medfilt
                     #Nincoh = 20
                     #Nincoh = 80
                     Nincoh = Nincoh
                     #spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     spcm = spc/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.double_gaussian_double_skew(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8]))/spcm
                     # fit
                     bounds=([0,-numpy.inf,0,-5,0,-400,0,0,0],[numpy.inf,-200,numpy.inf,5,numpy.inf,0,numpy.inf,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,1,spc_max,freq_max,freq_max,1,spc_max]
                     dop1_x0 = freq[numpy.argmax(spc)]
                     if dop1_x0 < 0:
                       dop2_x0 = dop1_x0 + 100
                     if dop1_x0 > 0:
                       dop2_x0 = dop1_x0 - 100
                     x0_value = numpy.array([spc_max,dop1_x0,30,-.1,spc_max/4, dop2_x0,150,1,1.0e7])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     J = popt.jac
                     try:
                         cov = numpy.linalg.inv(J.T.dot(J))
                         error = numpy.sqrt(numpy.diagonal(cov))
                     except:
                         error = numpy.ones((9))*numpy.NAN
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]; K1f = popt.x[3]
                     A2f = popt.x[4]; B2f = popt.x[5]; C2f = popt.x[6]; K2f = popt.x[7]
                     Df = popt.x[8]
                     aux1 = self.gaussian_skew(freq, A1f, B1f, C1f, K1f, Df)
                     doppler1 = freq[numpy.argmax(aux1)]
                     aux2 = self.gaussian_skew(freq, A2f, B2f, C2f, K2f, Df)
                     doppler2 = freq[numpy.argmax(aux2)]
                     #print("error",error)
                     #exit(1)
                     return A1f, B1f, C1f, K1f, A2f, B2f, C2f, K2f, Df, doppler1, doppler2, error
                 def Double_Gauss_fit_weight_bound_no_inputs(self,spc,freq,Nincoh):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = 20
                     Nincoh = 80
                     Nincoh = Nincoh
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.double_gaussian(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))/spcm
                     # fit
                 #    bounds=([0,-460,0,0,-400,120,0],[numpy.inf,-340,50,numpy.inf,0,250,numpy.inf])
                 #    bounds=([0,-numpy.inf,0,0,-numpy.inf,0,-numpy.inf,0],[numpy.inf,-200,numpy.inf,numpy.inf,0,numpy.inf,0,numpy.inf])
                     #print(a1,b1,c1,a2,b2,c2,k2,d)
                     dop1_x0 = freq[numpy.argmax(spcm)]
                     bounds=([0,-numpy.inf,0,0,dop1_x0-50,0,0],[numpy.inf,-300,numpy.inf,numpy.inf,0,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,spc_max]
                     x0_value = numpy.array([spc_max,-400.5,30,spc_max/4,dop1_x0,150,1.0e7])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     J = popt.jac
                     try:
                         cov = numpy.linalg.inv(J.T.dot(J))
                         error = numpy.sqrt(numpy.diagonal(cov))
                     except:
                         error = numpy.ones((7))*numpy.NAN
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     A2f = popt.x[3]; B2f = popt.x[4]; C2f = popt.x[5]
                     Df = popt.x[6]
                     return A1f, B1f, C1f, A2f, B2f, C2f, Df, error
                 def Double_Gauss_Double_Skew_fit_weight_bound_with_inputs(self, spc, freq, a1, b1, c1, a2, b2, c2, k2, d):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = dataOut.nIncohInt
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.double_gaussian_double_skew(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8]))/spcm
                     bounds=([0,-numpy.inf,0,-numpy.inf,0,-400,0,0,0],[numpy.inf,-340,numpy.inf,0,numpy.inf,0,numpy.inf,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,1,spc_max,freq_max,freq_max,1,spc_max]
                     x0_value = numpy.array([a1,b1,c1,-.1,a2,b2,c2,k2,d])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]; K1f = popt.x[3]
                     A2f = popt.x[4]; B2f = popt.x[5]; C2f = popt.x[6]; K2f = popt.x[7]
                     Df = popt.x[8]
                     aux = self.gaussian_skew(freq, A2f, B2f, C2f, K2f, Df)
                     doppler = x[numpy.argmax(aux)]
                     return A1f, B1f, C1f, K1f, A2f, B2f, C2f, K2f, Df, doppler
                 def Triple_Gauss_Skew_fit_weight_bound_no_inputs(self,spc,freq):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = 20
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.triple_gaussian_skew(freq,params[0],params[1],params[2],params[3],params[4],params[5],params[6],params[7],params[8],params[9],params[10],params[11]))/spcm
                     # fit
                     bounds=([0,-numpy.inf,0,0,-400,0,0,0,0,0,0,0],[numpy.inf,-340,numpy.inf,numpy.inf,0,numpy.inf,numpy.inf,numpy.inf,numpy.inf,numpy.inf,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max,freq_max,freq_max,1,spc_max,freq_max,freq_max,1,spc_max]
                     x0_value = numpy.array([spc_max,-400,30,spc_max/4,-200,150,1,spc_max/4,400,150,1,1.0e7])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     A2f = popt.x[3]; B2f = popt.x[4]; C2f = popt.x[5]; K2f = popt.x[6]
                     A3f = popt.x[7]; B3f = popt.x[8]; C3f = popt.x[9]; K3f = popt.x[10]
                     Df = popt.x[11]
                     aux = self.gaussian_skew(freq, A2f, B2f, C2f, K2f, Df)
                     doppler = freq[numpy.argmax(aux)]
                     return A1f, B1f, C1f, A2f, B2f, C2f, K2f, A3f, B3f, C3f, K3f, Df, doppler
                 def CEEJ_Skew_fit_weight_bound_no_inputs(self,spc,freq,Nincoh):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = 20
                     Nincoh = 80
                     Nincoh = Nincoh
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.gaussian_skew(freq,params[0],params[1],params[2],params[3],params[4]))#/spcm
                     bounds=([0,0,0,-numpy.inf,0],[numpy.inf,numpy.inf,numpy.inf,0,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,1,spc_max]
                     x0_value = numpy.array([spc_max,freq[numpy.argmax(spc)],30,-.1,numpy.mean(spc[:50])])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     J = popt.jac
                     try:
                         error = numpy.ones((9))*numpy.NAN
                         cov = numpy.linalg.inv(J.T.dot(J))
                         error[:4] = numpy.sqrt(numpy.diagonal(cov))[:4]
                         error[-1] = numpy.sqrt(numpy.diagonal(cov))[-1]
                     except:
                         error = numpy.ones((9))*numpy.NAN
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]; K1f = popt.x[3]
                     Df = popt.x[4]
                     aux1 = self.gaussian_skew(freq, A1f, B1f, C1f, K1f, Df)
                     doppler1 = freq[numpy.argmax(aux1)]
                     #print("CEEJ ERROR:",error)
                     return A1f, B1f, C1f, K1f, numpy.NAN, numpy.NAN, numpy.NAN, numpy.NAN, Df, doppler1, numpy.NAN, error
                 def CEEJ_fit_weight_bound_no_inputs(self,spc,freq,Nincoh):
                     from scipy.optimize import least_squares
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     from scipy.signal import medfilt
                     Nincoh = 20
                     Nincoh = 80
                     Nincoh = Nincoh
                     spcm = medfilt(spc,11)/numpy.sqrt(Nincoh)
                     # define a least squares function to optimize
                     def lsq_func(params):
                         return (spc-self.gaussian(freq,params[0],params[1],params[2],params[3]))#/spcm
                     bounds=([0,0,0,0],[numpy.inf,numpy.inf,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max]
                     x0_value = numpy.array([spc_max,freq[numpy.argmax(spcm)],30,numpy.mean(spc[:50])])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     J = popt.jac
                     try:
                         error = numpy.ones((4))*numpy.NAN
                         cov = numpy.linalg.inv(J.T.dot(J))
                         error = numpy.sqrt(numpy.diagonal(cov))
                     except:
                         error = numpy.ones((4))*numpy.NAN
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     Df = popt.x[3]
                     return A1f, B1f, C1f, Df, error
                 def Simple_fit_bound(self,spc,freq,Nincoh):
                     freq_max = numpy.max(numpy.abs(freq))
                     spc_max = numpy.max(spc)
                     Nincoh = Nincoh
                     def lsq_func(params):
                         return (spc-self.gaussian(freq,params[0],params[1],params[2],params[3]))
                     bounds=([0,-50,0,0],[numpy.inf,+50,numpy.inf,numpy.inf])
                     params_scale = [spc_max,freq_max,freq_max,spc_max]
                     x0_value = numpy.array([spc_max,-20.5,5,1.0e7])
                     popt = least_squares(lsq_func,x0=x0_value,x_scale=params_scale,bounds=bounds,verbose=0)
                     J = popt.jac
                     try:
                         cov = numpy.linalg.inv(J.T.dot(J))
                         error = numpy.sqrt(numpy.diagonal(cov))
                     except:
                         error = numpy.ones((4))*numpy.NAN
                     A1f = popt.x[0]; B1f = popt.x[1]; C1f = popt.x[2]
                     Df = popt.x[3]
                     return A1f, B1f, C1f, Df, error
                 def clean_outliers(self,param):
                     threshold = 700
                     param = numpy.where(param < -threshold, numpy.nan, param)
                     param = numpy.where(param > +threshold, numpy.nan, param)
                     return param
                 def windowing_single(self,spc,x,A,B,C,D,nFFTPoints):
                     from scipy.optimize import curve_fit,fmin
                     def R_gaussian(x, a, b, c):
                             N = int(numpy.shape(x)[0])
                             val = a * numpy.exp(-((x)*c*2*2*numpy.pi)**2 / (2))* numpy.exp(1.j*b*x*4*numpy.pi)
                             return val
                     def T(x,N):
                         T = 1-abs(x)/N
                         return T
                     def R_T_spc_fun(x, a, b, c, d, nFFTPoints):
                         N = int(numpy.shape(x)[0])
                         x_max = x[-1]
                         x_pos = x[int(nFFTPoints/2):]
                         x_neg = x[:int(nFFTPoints/2)]
                         R_T_neg_1 = R_gaussian(x, a, b, c)[:int(nFFTPoints/2)]*T(x_neg,-x[0])
                         R_T_pos_1 = R_gaussian(x, a, b, c)[int(nFFTPoints/2):]*T(x_pos,x[-1])
                         R_T_sum_1 = R_T_pos_1 + R_T_neg_1
                         R_T_spc_1 = numpy.fft.fft(R_T_sum_1).real
                         R_T_spc_1 = numpy.fft.fftshift(R_T_spc_1)
                         max_val_1 = numpy.max(R_T_spc_1)
                         R_T_spc_1 = R_T_spc_1*a/max_val_1
                         R_T_d = d*numpy.fft.fftshift(signal.unit_impulse(N))
                         R_T_d_neg = R_T_d[:int(nFFTPoints/2)]*T(x_neg,-x[0])
                         R_T_d_pos = R_T_d[int(nFFTPoints/2):]*T(x_pos,x[-1])
                         R_T_d_sum = R_T_d_pos + R_T_d_neg
                         R_T_spc_3 = numpy.fft.fft(R_T_d_sum).real
                         R_T_spc_3 = numpy.fft.fftshift(R_T_spc_3)
                         R_T_final = R_T_spc_1 + R_T_spc_3
                         return R_T_final
                     y = spc#gaussian(x, a, meanY, sigmaY) + a*0.1*numpy.random.normal(0, 1, size=len(x))
                     from scipy.stats import norm
                     mean,std=norm.fit(spc)
                     # estimate starting values from the data
                     a = A
                     b = B
                     c = C#numpy.std(spc)
                     d = D
                     '''
                     ippSeconds = 250*20*1.e-6/3
                     x_t = ippSeconds * (numpy.arange(1600) -1600 / 2.)
                     x_t = numpy.linspace(x_t[0],x_t[-1],3200)
                     x_freq = numpy.fft.fftfreq(1600,d=ippSeconds)
                     x_freq = numpy.fft.fftshift(x_freq)
                     '''
                     # define a least squares function to optimize
                     def minfunc(params):
                         return sum((y-R_T_spc_fun(x,params[0],params[1],params[2],params[3],params[4],params[5],params[6]))**2/1)#y**2)
                     # fit
                     popt_full = fmin(minfunc,[a,b,c,d],full_output=True)
                     #print("nIter", popt_full[2])
                     popt = popt_full[0]
                     #return R_T_spc_fun(x_t,popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]), popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                     return popt[0], popt[1], popt[2], popt[3]
                 def run(self, dataOut, mode = 0, Hmin1 = None, Hmax1 = None, Hmin2 = None, Hmax2 = None, Dop = 'Shift'):
                     pwcode = 1
                     if dataOut.flagDecodeData:
                         pwcode = numpy.sum(dataOut.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = dataOut.nProfiles * dataOut.nIncohInt * dataOut.nCohInt * pwcode * dataOut.windowOfFilter
                     factor = normFactor
                     z = dataOut.data_spc / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     dataOut.power = numpy.average(z, axis=1)
                     dataOut.powerdB = 10 * numpy.log10(dataOut.power)
                     x = dataOut.getVelRange(0)
                     dataOut.Oblique_params = numpy.ones((1,7,dataOut.nHeights))*numpy.NAN
                     dataOut.Oblique_param_errors = numpy.ones((1,7,dataOut.nHeights))*numpy.NAN
                     dataOut.dplr_2_u = numpy.ones((1,1,dataOut.nHeights))*numpy.NAN
                     if mode == 6:
                         dataOut.Oblique_params = numpy.ones((1,9,dataOut.nHeights))*numpy.NAN
                     elif mode == 7:
                         dataOut.Oblique_params = numpy.ones((1,13,dataOut.nHeights))*numpy.NAN
                     elif mode == 8:
                         dataOut.Oblique_params = numpy.ones((1,10,dataOut.nHeights))*numpy.NAN
                     elif mode == 9:
                         dataOut.Oblique_params = numpy.ones((1,11,dataOut.nHeights))*numpy.NAN
                         dataOut.Oblique_param_errors = numpy.ones((1,9,dataOut.nHeights))*numpy.NAN
                     elif mode == 11:
                         dataOut.Oblique_params = numpy.ones((1,7,dataOut.nHeights))*numpy.NAN
                         dataOut.Oblique_param_errors = numpy.ones((1,7,dataOut.nHeights))*numpy.NAN
                     elif mode == 10: #150 km
                         dataOut.Oblique_params = numpy.ones((1,4,dataOut.nHeights))*numpy.NAN
                         dataOut.Oblique_param_errors = numpy.ones((1,4,dataOut.nHeights))*numpy.NAN
                         dataOut.snr_log10 = numpy.ones((1,dataOut.nHeights))*numpy.NAN
                     dataOut.VelRange = x
                     #l1=range(22,36) #+62
                     #l1=range(32,36)
                     #l2=range(58,99) #+62
                     #if Hmin1 == None or Hmax1 == None or Hmin2 == None or Hmax2 == None:
                     minHei1 = 105.
                     maxHei1 = 122.5
                     maxHei1 = 130.5
                     if mode == 10: #150 km
                         minHei1 = 100
                         maxHei1 = 100
                     inda1 = numpy.where(dataOut.heightList >= minHei1)
                     indb1 = numpy.where(dataOut.heightList <= maxHei1)
                     minIndex1 = inda1[0][0]
                     maxIndex1 = indb1[0][-1]
                     minHei2 = 150.
                     maxHei2 = 201.25
                     maxHei2 = 225.3
                     if mode == 10: #150 km
                         minHei2 = 110
                         maxHei2 = 165
                     inda2 = numpy.where(dataOut.heightList >= minHei2)
                     indb2 = numpy.where(dataOut.heightList <= maxHei2)
                     minIndex2 = inda2[0][0]
                     maxIndex2 = indb2[0][-1]
                     l1=range(minIndex1,maxIndex1)
                     l2=range(minIndex2,maxIndex2)
                     if mode == 4:
                         '''
                         for ind in range(dataOut.nHeights):
                             if(dataOut.heightList[ind]>=168 and dataOut.heightList[ind]<188):
                                 try:
                                     dataOut.Oblique_params[0,0,ind],dataOut.Oblique_params[0,1,ind],dataOut.Oblique_params[0,2,ind],dataOut.Oblique_params[0,3,ind],dataOut.Oblique_params[0,4,ind],dataOut.Oblique_params[0,5,ind],dataOut.Oblique_params[0,6,ind],dataOut.Oblique_param_errors[0,0,ind],dataOut.Oblique_param_errors[0,1,ind],dataOut.Oblique_param_errors[0,2,ind],dataOut.Oblique_param_errors[0,3,ind],dataOut.Oblique_param_errors[0,4,ind],dataOut.Oblique_param_errors[0,5,ind],dataOut.Oblique_param_errors[0,6,ind] = self.DH_mode(dataOut.data_spc[0,:,ind],dataOut.VelRange)
                                 except:
                                     pass
                                     '''
                         for ind in itertools.chain(l1, l2):
                             try:
                                 dataOut.Oblique_params[0,0,ind],dataOut.Oblique_params[0,1,ind],dataOut.Oblique_params[0,2,ind],dataOut.Oblique_params[0,3,ind],dataOut.Oblique_params[0,4,ind],dataOut.Oblique_params[0,5,ind],dataOut.Oblique_params[0,6,ind],dataOut.Oblique_param_errors[0,0,ind],dataOut.Oblique_param_errors[0,1,ind],dataOut.Oblique_param_errors[0,2,ind],dataOut.Oblique_param_errors[0,3,ind],dataOut.Oblique_param_errors[0,4,ind],dataOut.Oblique_param_errors[0,5,ind],dataOut.Oblique_param_errors[0,6,ind] = self.DH_mode(dataOut.data_spc[0,:,ind],dataOut.VelRange)
                                 dataOut.dplr_2_u[0,0,ind] = dataOut.Oblique_params[0,4,ind]/numpy.sin(numpy.arccos(102/dataOut.heightList[ind]))
                             except:
                                 pass
                     else:
                         for hei in itertools.chain(l1, l2):
                             if numpy.isnan(dataOut.snl[0,hei]) or dataOut.snl[0,hei]<.0:
                                 continue #Avoids the analysis when there is only noise
                             try:
                                 spc = dataOut.data_spc[0,:,hei]
                                 if mode == 6: #Skew Weighted Bounded
                                     dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_params[0,7,hei],dataOut.Oblique_params[0,8,hei] = self.Double_Gauss_Skew_fit_weight_bound_no_inputs(spc,x)
                                     dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,8,hei]/numpy.sin(numpy.arccos(100./dataOut.heightList[hei]))
                                 elif mode == 7: #Triple Skew Weighted Bounded
                                     dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_params[0,7,hei],dataOut.Oblique_params[0,8,hei],dataOut.Oblique_params[0,9,hei],dataOut.Oblique_params[0,10,hei],dataOut.Oblique_params[0,11,hei],dataOut.Oblique_params[0,12,hei] = self.Triple_Gauss_Skew_fit_weight_bound_no_inputs(spc,x)
                                     dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,12,hei]/numpy.sin(numpy.arccos(100./dataOut.heightList[hei]))
                                 elif mode == 8: #Double Skewed Weighted Bounded with inputs
                                     a1, b1, c1, a2, b2, c2, k2, d, dopp = self.Double_Gauss_Skew_fit_weight_bound_no_inputs(spc,x)
                                     dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_params[0,7,hei],dataOut.Oblique_params[0,8,hei],dataOut.Oblique_params[0,9,hei] = self.Double_Gauss_Skew_fit_weight_bound_no_inputs(spc,x, a1, b1, c1, a2, b2, c2, k2, d)
                                     dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,9,hei]/numpy.sin(numpy.arccos(100./dataOut.heightList[hei]))
                                 elif mode == 9: #Double Skewed Weighted Bounded no inputs
                                     #if numpy.max(spc) <= 0:
                                     from scipy.signal import medfilt
                                     spcm = medfilt(spc,11)
                                     if x[numpy.argmax(spcm)] <= 0:
                                         #print("EEJ", dataOut.heightList[hei], hei)
                                         #if hei != 70:
                                             #continue
                                         #else:
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_params[0,7,hei],dataOut.Oblique_params[0,8,hei],dataOut.Oblique_params[0,9,hei],dataOut.Oblique_params[0,10,hei],dataOut.Oblique_param_errors[0,:,hei] = self.Double_Gauss_Double_Skew_fit_weight_bound_no_inputs(spcm,x,dataOut.nIncohInt,dataOut.heightList[hei])
                                         #if dataOut.Oblique_params[0,-2,hei] < -500 or dataOut.Oblique_params[0,-2,hei] > 500 or dataOut.Oblique_params[0,-1,hei] < -500 or dataOut.Oblique_params[0,-1,hei] > 500:
                                         #    dataOut.Oblique_params[0,:,hei] *= numpy.NAN
                                         dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,10,hei]/numpy.sin(numpy.arccos(100./dataOut.heightList[hei]))
                                     else:
                                         #print("CEEJ")
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_params[0,7,hei],dataOut.Oblique_params[0,8,hei],dataOut.Oblique_params[0,9,hei],dataOut.Oblique_params[0,10,hei],dataOut.Oblique_param_errors[0,:,hei] = self.CEEJ_Skew_fit_weight_bound_no_inputs(spcm,x,dataOut.nIncohInt)
                                         #if dataOut.Oblique_params[0,-2,hei] < -500 or dataOut.Oblique_params[0,-2,hei] > 500 or dataOut.Oblique_params[0,-1,hei] < -500 or dataOut.Oblique_params[0,-1,hei] > 500:
                                         #    dataOut.Oblique_params[0,:,hei] *= numpy.NAN
                                         dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,10,hei]/numpy.sin(numpy.arccos(100./dataOut.heightList[hei]))
                                 elif mode == 11: #Double Weighted Bounded no inputs
                                     #if numpy.max(spc) <= 0:
                                     from scipy.signal import medfilt
                                     spcm = medfilt(spc,11)
                                     if x[numpy.argmax(spcm)] <= 0:
                                         #print("EEJ")
                                         #print("EEJ",dataOut.heightList[hei])
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_param_errors[0,:,hei] = self.Double_Gauss_fit_weight_bound_no_inputs(spc,x,dataOut.nIncohInt)
                                         #if dataOut.Oblique_params[0,-2,hei] < -500 or dataOut.Oblique_params[0,-2,hei] > 500 or dataOut.Oblique_params[0,-1,hei] < -500 or dataOut.Oblique_params[0,-1,hei] > 500:
                                         #    dataOut.Oblique_params[0,:,hei] *= numpy.NAN
                                     else:
                                         #print("CEEJ",dataOut.heightList[hei])
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_param_errors[0,:,hei] = self.CEEJ_fit_weight_bound_no_inputs(spc,x,dataOut.nIncohInt)
                                 elif mode == 10: #150km
                                     dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_param_errors[0,:,hei] = self.Simple_fit_bound(spc,x,dataOut.nIncohInt)
                                     snr = (dataOut.power[0,hei]*factor - dataOut.Oblique_params[0,3,hei])/dataOut.Oblique_params[0,3,hei]
                                     dataOut.snr_log10[0,hei] = numpy.log10(snr)
                                 else:
                                     spc_fit, A1, B1, C1, D1 = self.Gauss_fit_2(spc,x,'first')
                                     spc_diff = spc - spc_fit
                                     spc_diff[spc_diff < 0] = 0
                                     spc_fit_diff, A2, B2, C2, D2 = self.Gauss_fit_2(spc_diff,x,'second')
                                     D = (D1+D2)
                                     if mode == 0: #Double Fit
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei],dataOut.Oblique_param_errors[0,0,hei],dataOut.Oblique_param_errors[0,1,hei],dataOut.Oblique_param_errors[0,2,hei],dataOut.Oblique_param_errors[0,3,hei],dataOut.Oblique_param_errors[0,4,hei],dataOut.Oblique_param_errors[0,5,hei],dataOut.Oblique_param_errors[0,6,hei] = self.Double_Gauss_fit_2(spc,x,A1,B1,C1,A2,B2,C2,D)
                                     #spc_double_fit,dataOut.Oblique_params = self.Double_Gauss_fit(spc,x,A1,B1,C1,A2,B2,C2,D)
                                     elif mode == 1: #Double Fit Windowed
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei] = self.windowing_double(spc,dataOut.getFreqRange(0),A1,B1,C1,A2,B2,C2,D)
                                     elif mode == 2: #Double Fit Weight
                                         dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei] = self.Double_Gauss_fit_weight(spc,x,A1,B1,C1,A2,B2,C2,D)
                                     elif mode == 3: #Simple Fit
                                         dataOut.Oblique_params[0,0,hei] = A1
                                         dataOut.Oblique_params[0,1,hei] = B1
                                         dataOut.Oblique_params[0,2,hei] = C1
                                         dataOut.Oblique_params[0,3,hei] = A2
                                         dataOut.Oblique_params[0,4,hei] = B2
                                         dataOut.Oblique_params[0,5,hei] = C2
                                         dataOut.Oblique_params[0,6,hei] = D
                                     elif mode == 5: #Triple Fit Weight
                                         if hei in l1:
                                             dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei] = self.duo_Marco(spc,x,A1,B1,C1,A2,B2,C2,D)
                                             dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,4,hei]/numpy.sin(numpy.arccos(102/dataOut.heightList[hei]))
                                             #print(dataOut.Oblique_params[0,0,hei])
                                             #print(dataOut.dplr_2_u[0,0,hei])
                                         else:
                                             dataOut.Oblique_params[0,0,hei],dataOut.Oblique_params[0,1,hei],dataOut.Oblique_params[0,2,hei],dataOut.Oblique_params[0,3,hei],dataOut.Oblique_params[0,4,hei],dataOut.Oblique_params[0,5,hei],dataOut.Oblique_params[0,6,hei] = self.Double_Gauss_fit_weight(spc,x,A1,B1,C1,A2,B2,C2,D)
                                             dataOut.dplr_2_u[0,0,hei] = dataOut.Oblique_params[0,4,hei]/numpy.sin(numpy.arccos(102/dataOut.heightList[hei]))
                             except:
                                 ###dataOut.Oblique_params[0,:,hei] = dataOut.Oblique_params[0,:,hei]*numpy.NAN
                                 pass
                     #exit(1)
                     dataOut.paramInterval = dataOut.nProfiles*dataOut.nCohInt*dataOut.ippSeconds
                     dataOut.lat=-11.95
                     dataOut.lon=-76.87
                     '''
                     dataOut.Oblique_params = numpy.where(dataOut.Oblique_params<-700, numpy.nan, dop_t1)
                     dataOut.Oblique_params = numpy.where(dataOut.Oblique_params<+700, numpy.nan, dop_t1)
                     Aquí debo exceptuar las amplitudes
                     '''
                     if mode == 9: #Double Skew Gaussian
                         #dataOut.Dop_EEJ_T1 = dataOut.Oblique_params[:,-2,:] #Pos[Max_value]
                         #dataOut.Dop_EEJ_T1 = dataOut.Oblique_params[:,1,:] #Shift
                         dataOut.Spec_W_T1 = dataOut.Oblique_params[:,2,:]
                         #dataOut.Dop_EEJ_T2 = dataOut.Oblique_params[:,-1,:] #Pos[Max_value]
                         #dataOut.Dop_EEJ_T2 = dataOut.Oblique_params[:,5,:] #Shift
                         dataOut.Spec_W_T2 = dataOut.Oblique_params[:,6,:]
                         if Dop == 'Shift':
                             dataOut.Dop_EEJ_T1 = dataOut.Oblique_params[:,1,:] #Shift
                             dataOut.Dop_EEJ_T2 = dataOut.Oblique_params[:,5,:] #Shift
                         elif Dop == 'Max':
                             dataOut.Dop_EEJ_T1 = dataOut.Oblique_params[:,-2,:] #Pos[Max_value]
                             dataOut.Dop_EEJ_T2 = dataOut.Oblique_params[:,-1,:] #Pos[Max_value]
                         dataOut.Err_Dop_EEJ_T1 = dataOut.Oblique_param_errors[:,1,:] #En realidad este es el error?
                         dataOut.Err_Spec_W_T1 = dataOut.Oblique_param_errors[:,2,:]
                         dataOut.Err_Dop_EEJ_T2 = dataOut.Oblique_param_errors[:,5,:] #En realidad este es el error?
                         dataOut.Err_Spec_W_T2 = dataOut.Oblique_param_errors[:,6,:]
                     elif mode == 11: #Double Gaussian
                         dataOut.Dop_EEJ_T1 = dataOut.Oblique_params[:,1,:]
                         dataOut.Spec_W_T1 = dataOut.Oblique_params[:,2,:]
                         dataOut.Dop_EEJ_T2 = dataOut.Oblique_params[:,4,:]
                         dataOut.Spec_W_T2 = dataOut.Oblique_params[:,5,:]
                         dataOut.Err_Dop_EEJ_T1 = dataOut.Oblique_param_errors[:,1,:]
                         dataOut.Err_Spec_W_T1 = dataOut.Oblique_param_errors[:,2,:]
                         dataOut.Err_Dop_EEJ_T2 = dataOut.Oblique_param_errors[:,4,:]
                         dataOut.Err_Spec_W_T2 = dataOut.Oblique_param_errors[:,5,:]
                     #print("Before: ", dataOut.Dop_EEJ_T2)
                     dataOut.Spec_W_T1 = self.clean_outliers(dataOut.Spec_W_T1)
                     dataOut.Spec_W_T2 = self.clean_outliers(dataOut.Spec_W_T2)
                     dataOut.Dop_EEJ_T1 = self.clean_outliers(dataOut.Dop_EEJ_T1)
                     dataOut.Dop_EEJ_T2 = self.clean_outliers(dataOut.Dop_EEJ_T2)
                     #print("After: ", dataOut.Dop_EEJ_T2)
                     dataOut.Err_Spec_W_T1 = self.clean_outliers(dataOut.Err_Spec_W_T1)
                     dataOut.Err_Spec_W_T2 = self.clean_outliers(dataOut.Err_Spec_W_T2)
                     dataOut.Err_Dop_EEJ_T1 = self.clean_outliers(dataOut.Err_Dop_EEJ_T1)
                     dataOut.Err_Dop_EEJ_T2 = self.clean_outliers(dataOut.Err_Dop_EEJ_T2)
                     #print("Before data_snr: ", dataOut.data_snr)
                     #dataOut.data_snr = numpy.where(numpy.isnan(dataOut.Dop_EEJ_T1), numpy.nan, dataOut.data_snr)
                     dataOut.snl = numpy.where(numpy.isnan(dataOut.Dop_EEJ_T1), numpy.nan, dataOut.snl)
                     #print("After data_snr: ", dataOut.data_snr)
                     dataOut.mode = mode
                     dataOut.flagNoData = numpy.all(numpy.isnan(dataOut.Dop_EEJ_T1)) #Si todos los valores son NaN no se prosigue
                     ###dataOut.flagNoData = False #Descomentar solo para ploteo sino mantener comentado (para guardado)
                     return dataOut
             class Gaussian_Windowed(Operation):
                 '''
                 Written by R. Flores
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                 def windowing_single(self,spc,x,A,B,C,D,nFFTPoints):
                     from scipy.optimize import curve_fit,fmin
                     def gaussian(x, a, b, c, d):
                         val = a * numpy.exp(-(x - b)**2 / (2*c**2)) + d
                         return val
                     def R_gaussian(x, a, b, c):
                             N = int(numpy.shape(x)[0])
                             val = a * numpy.exp(-((x)*c*2*2*numpy.pi)**2 / (2))* numpy.exp(1.j*b*x*4*numpy.pi)
                             return val
                     def T(x,N):
                         T = 1-abs(x)/N
                         return T
                     def R_T_spc_fun(x, a, b, c, d, nFFTPoints):
                         N = int(numpy.shape(x)[0])
                         x_max = x[-1]
                         x_pos = x[nFFTPoints:]
                         x_neg = x[:nFFTPoints]
                         #print([int(nFFTPoints/2))
                         #print("x: ", x)
                         #print("x_neg: ", x_neg)
                         #print("x_pos: ", x_pos)
                         R_T_neg_1 = R_gaussian(x, a, b, c)[:nFFTPoints]*T(x_neg,-x[0])
                         R_T_pos_1 = R_gaussian(x, a, b, c)[nFFTPoints:]*T(x_pos,x[-1])
                         #print(T(x_pos,x[-1]),x_pos,x[-1])
                         #print(R_T_neg_1.shape,R_T_pos_1.shape)
                         R_T_sum_1 = R_T_pos_1 + R_T_neg_1
                         R_T_spc_1 = numpy.fft.fft(R_T_sum_1).real
                         R_T_spc_1 = numpy.fft.fftshift(R_T_spc_1)
                         max_val_1 = numpy.max(R_T_spc_1)
                         R_T_spc_1 = R_T_spc_1*a/max_val_1
                         R_T_d = d*numpy.fft.fftshift(signal.unit_impulse(N))
                         R_T_d_neg = R_T_d[:nFFTPoints]*T(x_neg,-x[0])
                         R_T_d_pos = R_T_d[nFFTPoints:]*T(x_pos,x[-1])
                         R_T_d_sum = R_T_d_pos + R_T_d_neg
                         R_T_spc_3 = numpy.fft.fft(R_T_d_sum).real
                         R_T_spc_3 = numpy.fft.fftshift(R_T_spc_3)
                         R_T_final = R_T_spc_1 + R_T_spc_3
                         return R_T_final
                     y = spc#gaussian(x, a, meanY, sigmaY) + a*0.1*numpy.random.normal(0, 1, size=len(x))
                     from scipy.stats import norm
                     mean,std=norm.fit(spc)
                     # estimate starting values from the data
                     a = A
                     b = B
                     c = C#numpy.std(spc)
                     d = D
                     #'''
                     #ippSeconds = 250*20*1.e-6/3
                     #x_t = ippSeconds * (numpy.arange(nFFTPoints) - nFFTPoints / 2.)
                     #x_t = numpy.linspace(x_t[0],x_t[-1],3200)
                     #print("x_t: ", x_t)
                     #print("nFFTPoints: ", nFFTPoints)
                     x_vel = numpy.linspace(x[0],x[-1],int(2*nFFTPoints))
                     #print("x_vel: ", x_vel)
                     #x_freq = numpy.fft.fftfreq(1600,d=ippSeconds)
                     #x_freq = numpy.fft.fftshift(x_freq)
                     #'''
                     # define a least squares function to optimize
                     def minfunc(params):
                         #print("y.shape: ", numpy.shape(y))
                         return sum((y-R_T_spc_fun(x_vel,params[0],params[1],params[2],params[3],nFFTPoints))**2/1)#y**2)
                     # fit
                     popt_full = fmin(minfunc,[a,b,c,d], disp=False)
                     #print("nIter", popt_full[2])
                     popt = popt_full#[0]
                     fun = gaussian(x, popt[0], popt[1], popt[2], popt[3])
                     #return R_T_spc_fun(x_t,popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]), popt[0], popt[1], popt[2], popt[3], popt[4], popt[5], popt[6]
                     return fun, popt[0], popt[1], popt[2], popt[3]
                 def run(self, dataOut):
                     from scipy.signal import medfilt
                     import matplotlib.pyplot as plt
                     dataOut.moments = numpy.ones((dataOut.nChannels,4,dataOut.nHeights))*numpy.NAN
                     dataOut.VelRange = dataOut.getVelRange(0)
                     for nChannel in range(dataOut.nChannels):
                         for hei in range(dataOut.heightList.shape[0]):
                             #print("ipp: ", dataOut.ippSeconds)
                             spc = numpy.copy(dataOut.data_spc[nChannel,:,hei])
                             #print(VelRange)
                             #print(dataOut.getFreqRange(64))
                             spcm = medfilt(spc,11)
                             spc_max = numpy.max(spcm)
                             dop1_x0 = dataOut.VelRange[numpy.argmax(spcm)]
                             D = numpy.min(spcm)
                             fun, A, B, C, D = self.windowing_single(spc,dataOut.VelRange,spc_max,dop1_x0,abs(dop1_x0),D,dataOut.nFFTPoints)
                             dataOut.moments[nChannel,0,hei] = A
                             dataOut.moments[nChannel,1,hei] = B
                             dataOut.moments[nChannel,2,hei] = C
                             dataOut.moments[nChannel,3,hei] = D
                             '''
                             plt.figure()
                             plt.plot(VelRange,spc,marker='*',linestyle='')
                             plt.plot(VelRange,fun)
                             plt.title(dataOut.heightList[hei])
                             plt.show()
                             '''
                     return dataOut
             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 __init__(self):
                     Operation.__init__(self)
                     self.i=0
                 def run(self, dataOut, radar=None, Pt=5000, Gt=295.1209, Gr=70.7945, Lambda=0.6741, aL=2.5118,
                         tauW=4e-06, ThetaT=0.1656317, ThetaR=0.36774087, Km2 = 0.93, Altitude=3350,SNRdBlimit=-30,
                         channel=None):
                     # print ('Entering PrecepitationProc ... ')
                     if radar == "MIRA35C" :
                         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]
                         Ze = self.dBZeMODE2(dataOut)
                     else:
                         self.spc = dataOut.data_pre[0].copy()
                         #NOTA SE DEBE REMOVER EL RANGO DEL PULSO TX
                         self.spc[:,:,0:7]= numpy.NaN
                         self.Num_Hei = self.spc.shape[2]
                         self.Num_Bin = self.spc.shape[1]
                         self.Num_Chn = self.spc.shape[0]
                         VelRange = dataOut.spc_range[2]
                         ''' Se obtiene la constante del RADAR '''
                         self.Pt = Pt
                         self.Gt = Gt
                         self.Gr = Gr
                         self.Lambda = Lambda
                         self.aL = aL
                         self.tauW = tauW
                         self.ThetaT = ThetaT
                         self.ThetaR = ThetaR
                         self.GSys = 10**(36.63/10) # Ganancia de los LNA 36.63 dB
                         self.lt = 10**(1.67/10) # Perdida en cables Tx 1.67 dB
                         self.lr = 10**(5.73/10) # Perdida en cables Rx 5.73 dB
                         Numerator = ( (4*numpy.pi)**3 * aL**2 * 16 * numpy.log(2) )
                         Denominator = ( Pt * Gt * Gr * Lambda**2 * SPEED_OF_LIGHT * tauW * numpy.pi * ThetaT * ThetaR)
                         RadarConstant = 10e-26 * Numerator / Denominator #
                         ExpConstant = 10**(40/10) #Constante Experimental
                         SignalPower = numpy.zeros([self.Num_Chn,self.Num_Bin,self.Num_Hei])
                         for i in range(self.Num_Chn):
                             SignalPower[i,:,:] = self.spc[i,:,:] - dataOut.noise[i]
                             SignalPower[numpy.where(SignalPower < 0)] = 1e-20
                         if channel is None:
                             SPCmean = numpy.mean(SignalPower, 0)
                         else:
                             SPCmean = SignalPower[channel]
                         Pr = SPCmean[:,:]/dataOut.normFactor
                         # Declaring auxiliary variables
                         Range = dataOut.heightList*1000. #Range in m
                         # replicate the heightlist to obtain a matrix [Num_Bin,Num_Hei]
                         rMtrx = numpy.transpose(numpy.transpose([dataOut.heightList*1000.] * self.Num_Bin))
                         zMtrx = rMtrx+Altitude
                         # replicate the VelRange to obtain a matrix [Num_Bin,Num_Hei]
                         VelMtrx = numpy.transpose(numpy.tile(VelRange[:-1], (self.Num_Hei,1)))
                         # height dependence to air density Foote and Du Toit (1969)
                         delv_z = 1 + 3.68e-5 * zMtrx + 1.71e-9 * zMtrx**2
                         VMtrx = VelMtrx / delv_z #Normalized velocity
                         VMtrx[numpy.where(VMtrx> 9.6)] = numpy.NaN
                         # Diameter is related to the fall speed of falling drops
                         D_Vz = -1.667 * numpy.log( 0.9369 - 0.097087 * VMtrx ) # D in [mm]
                         # Only valid for D>= 0.16 mm
                         D_Vz[numpy.where(D_Vz < 0.16)] = numpy.NaN
                         #Calculate Radar Reflectivity ETAn
                         ETAn = (RadarConstant *ExpConstant) * Pr * rMtrx**2  #Reflectivity (ETA)
                         ETAd = ETAn * 6.18 * exp( -0.6 * D_Vz ) * delv_z
                         # Radar Cross Section
                         sigmaD = Km2 * (D_Vz * 1e-3 )**6 * numpy.pi**5 / Lambda**4
                         # Drop Size Distribution
                         DSD = ETAn / sigmaD
                         # Equivalente Reflectivy
                         Ze_eqn = numpy.nansum( DSD * D_Vz**6 ,axis=0)
                         Ze_org = numpy.nansum(ETAn * Lambda**4, axis=0) / (1e-18*numpy.pi**5 * Km2) # [mm^6 /m^3]
                         # RainFall Rate
                         RR = 0.0006*numpy.pi * numpy.nansum( D_Vz**3 * DSD * VelMtrx ,0) #mm/hr
                     # Censoring the data
                     # Removing data with SNRth < 0dB se debe considerar el SNR por canal
                     SNRth = 10**(SNRdBlimit/10) #-30dB
                     novalid = numpy.where((dataOut.data_snr[0,:] <SNRth) | (dataOut.data_snr[1,:] <SNRth) | (dataOut.data_snr[2,:] <SNRth)) # AND condition. Maybe OR condition better
                     W = numpy.nanmean(dataOut.data_dop,0)
                     W[novalid] = numpy.NaN
                     Ze_org[novalid] = numpy.NaN
                     RR[novalid] = numpy.NaN
                     dataOut.data_output = RR[8]
                     dataOut.data_param = numpy.ones([3,self.Num_Hei])
                     dataOut.channelList = [0,1,2]
                     dataOut.data_param[0]=10*numpy.log10(Ze_org)
                     dataOut.data_param[1]=-W
                     dataOut.data_param[2]=RR
                     # print ('Leaving PrecepitationProc ... ')
                     return dataOut
                 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)
                     ETA = numpy.where(ETA != 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        5kW                5000
             #         Gt:     Transmission Gain                dB        24.7 dB            295.1209
             #         Gr:     Reception Gain                   dB        18.5 dB            70.7945
             #         Lambda: Wavelenght                       m         0.6741 m           0.6741
             #         aL:     Attenuation loses                dB        4dB                2.5118
             #         tauW:   Width of transmission pulse      s         4us                4e-6
             #         ThetaT: Transmission antenna bean angle  rad       0.1656317 rad      0.1656317
             #         ThetaR: Reception antenna beam angle     rad       0.36774087 rad     0.36774087
             #
             #         """
             #
             #         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 Analysis 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, Xi01=None, Xi02=None, Xi12=None, Eta01=None, Eta02=None, Eta12=None, SNRdBlimit=-30,
                     minheight=None, maxheight=None, NegativeLimit=None, PositiveLimit=None):
                     spc = dataOut.data_pre[0].copy()
                     cspc = dataOut.data_pre[1]
                     nHeights = spc.shape[2]
                     # first_height = 0.75 #km (ref: data header 20170822)
                     # resolution_height = 0.075 #km
                     '''
                         finding height range. check this when radar parameters are changed!
                     '''
                     if maxheight is not None:
                         # range_max = math.ceil((maxheight - first_height) / resolution_height) # theoretical
                         range_max = math.ceil(13.26 * maxheight - 3) # empirical, works better
                     else:
                         range_max = nHeights
                     if minheight is not None:
                         # range_min = int((minheight - first_height) / resolution_height) # theoretical
                         range_min = int(13.26 * minheight - 5) # empirical, works better
                         if range_min < 0:
                             range_min = 0
                     else:
                         range_min = 0
                     pairsList = dataOut.groupList
                     if dataOut.ChanDist is not None :
                         ChanDist = dataOut.ChanDist
                     else:
                         ChanDist = numpy.array([[Xi01, Eta01],[Xi02,Eta02],[Xi12,Eta12]])
                     # 4 variables: zonal, meridional, vertical, and average SNR
                     data_param = numpy.zeros([4,nHeights]) * numpy.NaN
                     velocityX = numpy.zeros([nHeights]) * numpy.NaN
                     velocityY = numpy.zeros([nHeights]) * numpy.NaN
                     velocityZ = numpy.zeros([nHeights]) * numpy.NaN
                     dbSNR = 10*numpy.log10(numpy.average(dataOut.data_snr,0))
                     '''***********************************************WIND ESTIMATION**************************************'''
                     for Height in range(nHeights):
                         if Height >= range_min and Height < range_max:
                             # error_code will be useful in future analysis
                             [Vzon,Vmer,Vver, error_code] = self.WindEstimation(spc[:,:,Height], cspc[:,:,Height], pairsList,
                                 ChanDist, Height, dataOut.noise, dataOut.spc_range, dbSNR[Height], SNRdBlimit, NegativeLimit, PositiveLimit,dataOut.frequency)
                         if abs(Vzon) < 100. and abs(Vmer) < 100.:
                             velocityX[Height] = Vzon
                             velocityY[Height] = -Vmer
                             velocityZ[Height] = Vver
                     # Censoring data with SNR threshold
                     dbSNR [dbSNR < SNRdBlimit] = numpy.NaN
                     data_param[0] = velocityX
                     data_param[1] = velocityY
                     data_param[2] = velocityZ
                     data_param[3] = dbSNR
                     dataOut.data_param = data_param
                     return dataOut
                 def moving_average(self,x, N=2):
                     """ convolution for smoothenig data. note that last N-1 values are convolution with zeroes """
                     return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
                 def gaus(self,xSamples,Amp,Mu,Sigma):
                     return Amp * numpy.exp(-0.5*((xSamples - Mu)/Sigma)**2)
                 def Moments(self, ySamples, xSamples):
                     Power = numpy.nanmean(ySamples)                                 # Power, 0th Moment
                     yNorm = ySamples / numpy.nansum(ySamples)
                     RadVel = numpy.nansum(xSamples * yNorm)                         # Radial Velocity, 1st Moment
                     Sigma2 = numpy.nansum(yNorm * (xSamples - RadVel)**2)      # Spectral Width, 2nd Moment
                     StdDev = numpy.sqrt(numpy.abs(Sigma2))                                            # Desv. Estandar, Ancho espectral
                     return numpy.array([Power,RadVel,StdDev])
                 def StopWindEstimation(self, error_code):
                     Vzon = numpy.NaN
                     Vmer = numpy.NaN
                     Vver = numpy.NaN
                     return Vzon, Vmer, Vver, error_code
                 def AntiAliasing(self, interval, maxstep):
                     """
                         function to prevent errors from aliased values when computing phaseslope
                     """
                     antialiased = numpy.zeros(len(interval))
                     copyinterval = interval.copy()
                     antialiased[0] = copyinterval[0]
                     for i in range(1,len(antialiased)):
                         step = interval[i] - interval[i-1]
                         if step > maxstep:
                             copyinterval -= 2*numpy.pi
                             antialiased[i] = copyinterval[i]
                         elif step < maxstep*(-1):
                             copyinterval += 2*numpy.pi
                             antialiased[i] = copyinterval[i]
                         else:
                             antialiased[i] = copyinterval[i].copy()
                     return antialiased
                 def WindEstimation(self, spc, cspc, pairsList, ChanDist, Height, noise, AbbsisaRange, dbSNR, SNRlimit, NegativeLimit, PositiveLimit, radfreq):
                     """
                         Function that Calculates Zonal, Meridional and Vertical wind velocities.
                         Initial Version by E. Bocanegra updated by J. Zibell until Nov. 2019.
                         Input:
                             spc, cspc       : self spectra and cross spectra data. In Briggs notation something like S_i*(S_i)_conj, (S_j)_conj respectively.
                             pairsList       : Pairlist of channels
                             ChanDist        : array of xi_ij and eta_ij
                             Height          : height at which data is processed
                             noise           : noise in [channels] format for specific height
                             Abbsisarange    : range of the frequencies or velocities
                             dbSNR, SNRlimit : signal to noise ratio in db, lower limit
                         Output:
                             Vzon, Vmer, Vver         : wind velocities
                             error_code               : int that states where code is terminated
 : no error detected
 : Gaussian of mean spc exceeds widthlimit
 : no Gaussian of mean spc found
 : SNR to low or velocity to high -> prec. e.g.
 : at least one Gaussian of cspc exceeds widthlimit
 : zero out of three cspc Gaussian fits converged
 : phase slope fit could not be found
 : arrays used to fit phase have different length
 : frequency range is either too short (len <= 5) or very long (> 30% of cspc)
                     """
                     error_code = 0
                     nChan = spc.shape[0]
                     nProf = spc.shape[1]
                     nPair = cspc.shape[0]
                     SPC_Samples = numpy.zeros([nChan, nProf])           # for normalized spc values for one height
                     CSPC_Samples = numpy.zeros([nPair, nProf], dtype=numpy.complex_)      # for normalized cspc values
                     phase = numpy.zeros([nPair, nProf])                 # phase between channels
                     PhaseSlope = numpy.zeros(nPair)                     # slope of the phases, channelwise
                     PhaseInter = numpy.zeros(nPair)                     # intercept to the slope of the phases, channelwise
                     xFrec = AbbsisaRange[0][:-1]                        # frequency range
                     xVel = AbbsisaRange[2][:-1]                         # velocity range
                     xSamples = xFrec                                    # the frequency range is taken
                     delta_x = xSamples[1] - xSamples[0]                 # delta_f or delta_x
                     # only consider velocities with in NegativeLimit and PositiveLimit
                     if (NegativeLimit is None):
                         NegativeLimit = numpy.min(xVel)
                     if (PositiveLimit is None):
                         PositiveLimit = numpy.max(xVel)
                     xvalid = numpy.where((xVel > NegativeLimit) & (xVel < PositiveLimit))
                     xSamples_zoom = xSamples[xvalid]
                     '''Getting Eij and Nij'''
                     Xi01, Xi02, Xi12 = ChanDist[:,0]
                     Eta01, Eta02, Eta12 = ChanDist[:,1]
                     # spwd limit - updated by D. Scipión 30.03.2021
                     widthlimit = 10
                     '''************************* SPC is normalized ********************************'''
                     spc_norm = spc.copy()
                     # For each channel
                     for i in range(nChan):
                         spc_sub = spc_norm[i,:] - noise[i]  # only the signal power
                         SPC_Samples[i] = spc_sub / (numpy.nansum(spc_sub) * delta_x)
                     '''********************** FITTING MEAN SPC GAUSSIAN **********************'''
                     """ the gaussian of the mean: first subtract noise, then normalize. this is legal because
                         you only fit the curve and don't need the absolute value of height for calculation,
                         only for estimation of width. for normalization of cross spectra, you need initial,
                         unnormalized self-spectra With noise.
                         Technically, you don't even need to normalize the self-spectra, as you only need the
                         width of the peak. However, it was left this way. Note that the normalization has a flaw:
                         due to subtraction of the noise, some values are below zero. Raw "spc" values should be
                         >= 0, as it is the modulus squared of the signals (complex * it's conjugate)
                     """
                     # initial conditions
                     popt = [1e-10,0,1e-10]
                     # Spectra average
                     SPCMean = numpy.average(SPC_Samples,0)
                     # Moments in frequency
                     SPCMoments = self.Moments(SPCMean[xvalid], xSamples_zoom)
                     # Gauss Fit SPC in frequency domain
                     if dbSNR > SNRlimit: # only if SNR > SNRth
                         try:
                             popt,pcov = curve_fit(self.gaus,xSamples_zoom,SPCMean[xvalid],p0=SPCMoments)
                             if popt[2] <= 0 or popt[2] > widthlimit: # CONDITION
                                 return self.StopWindEstimation(error_code = 1)
                             FitGauss = self.gaus(xSamples_zoom,*popt)
                         except :#RuntimeError:
                             return self.StopWindEstimation(error_code = 2)
                     else:
                         return self.StopWindEstimation(error_code = 3)
                     '''***************************** CSPC Normalization *************************
                             The Spc spectra are used to normalize the crossspectra. Peaks from precipitation
                             influence the norm which is not desired. First, a range is identified where the
                             wind peak is estimated -> sum_wind is sum of those frequencies. Next, the area
                             around it gets cut off and values replaced by mean determined by the boundary
                             data -> sum_noise (spc is not normalized here, thats why the noise is important)
                             The sums are then added and multiplied by range/datapoints, because you need
                             an integral and not a sum for normalization.
                             A norm is found according to Briggs 92.
                     '''
                     # for each pair
                     for i in range(nPair):
                         cspc_norm = cspc[i,:].copy()
                         chan_index0 = pairsList[i][0]
                         chan_index1 = pairsList[i][1]
                         CSPC_Samples[i] = cspc_norm / (numpy.sqrt(numpy.nansum(spc_norm[chan_index0])*numpy.nansum(spc_norm[chan_index1])) * delta_x)
                         phase[i] = numpy.arctan2(CSPC_Samples[i].imag, CSPC_Samples[i].real)
                     CSPCmoments = numpy.vstack([self.Moments(numpy.abs(CSPC_Samples[0,xvalid]), xSamples_zoom),
                                                 self.Moments(numpy.abs(CSPC_Samples[1,xvalid]), xSamples_zoom),
                                                 self.Moments(numpy.abs(CSPC_Samples[2,xvalid]), xSamples_zoom)])
                     popt01, popt02, popt12 = [1e-10,0,1e-10], [1e-10,0,1e-10] ,[1e-10,0,1e-10]
                     FitGauss01, FitGauss02, FitGauss12 = numpy.zeros(len(xSamples)), numpy.zeros(len(xSamples)), numpy.zeros(len(xSamples))
                     '''*******************************FIT GAUSS CSPC************************************'''
                     try:
                         popt01,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[0][xvalid]),p0=CSPCmoments[0])
                         if popt01[2] > widthlimit: # CONDITION
                             return self.StopWindEstimation(error_code = 4)
                         popt02,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[1][xvalid]),p0=CSPCmoments[1])
                         if popt02[2] > widthlimit: # CONDITION
                             return self.StopWindEstimation(error_code = 4)
                         popt12,pcov = curve_fit(self.gaus,xSamples_zoom,numpy.abs(CSPC_Samples[2][xvalid]),p0=CSPCmoments[2])
                         if popt12[2] > widthlimit: # CONDITION
                             return self.StopWindEstimation(error_code = 4)
                         FitGauss01 = self.gaus(xSamples_zoom, *popt01)
                         FitGauss02 = self.gaus(xSamples_zoom, *popt02)
                         FitGauss12 = self.gaus(xSamples_zoom, *popt12)
                     except:
                         return self.StopWindEstimation(error_code = 5)
                     '''************* Getting Fij ***************'''
                     # x-axis point of the gaussian where the center is located from GaussFit of spectra
                     GaussCenter = popt[1]
                     ClosestCenter = xSamples_zoom[numpy.abs(xSamples_zoom-GaussCenter).argmin()]
                     PointGauCenter = numpy.where(xSamples_zoom==ClosestCenter)[0][0]
                     # Point where e^-1 is located in the gaussian
                     PeMinus1 = numpy.max(FitGauss) * numpy.exp(-1)
                     FijClosest = FitGauss[numpy.abs(FitGauss-PeMinus1).argmin()] # The closest point to"Peminus1" in "FitGauss"
                     PointFij = numpy.where(FitGauss==FijClosest)[0][0]
                     Fij = numpy.abs(xSamples_zoom[PointFij] - xSamples_zoom[PointGauCenter])
                     '''********** Taking frequency ranges from mean SPCs **********'''
                     GauWidth = popt[2] * 3/2        # Bandwidth of Gau01
                     Range = numpy.empty(2)
                     Range[0] = GaussCenter - GauWidth
                     Range[1] = GaussCenter + GauWidth
                     # Point in x-axis where the bandwidth is located (min:max)
                     ClosRangeMin = xSamples_zoom[numpy.abs(xSamples_zoom-Range[0]).argmin()]
                     ClosRangeMax = xSamples_zoom[numpy.abs(xSamples_zoom-Range[1]).argmin()]
                     PointRangeMin = numpy.where(xSamples_zoom==ClosRangeMin)[0][0]
                     PointRangeMax = numpy.where(xSamples_zoom==ClosRangeMax)[0][0]
                     Range = numpy.array([ PointRangeMin, PointRangeMax ])
                     FrecRange = xSamples_zoom[ Range[0] : Range[1] ]
                     '''************************** Getting Phase Slope ***************************'''
                     for i in range(nPair):
                         if len(FrecRange) > 5:
                             PhaseRange = phase[i, xvalid[0][Range[0]:Range[1]]].copy()
                             mask = ~numpy.isnan(FrecRange) & ~numpy.isnan(PhaseRange)
                             if len(FrecRange) == len(PhaseRange):
                                 try:
                                     slope, intercept, _, _, _ = stats.linregress(FrecRange[mask], self.AntiAliasing(PhaseRange[mask], 4.5))
                                     PhaseSlope[i] = slope
                                     PhaseInter[i] = intercept
                                 except:
                                     return self.StopWindEstimation(error_code = 6)
                             else:
                                 return self.StopWindEstimation(error_code = 7)
                         else:
                             return self.StopWindEstimation(error_code = 8)
                     '''*** Constants A-H correspond to the convention as in Briggs and Vincent 1992 ***'''
                     '''Getting constant C'''
                     cC=(Fij*numpy.pi)**2
                     '''****** Getting constants F and G ******'''
                     MijEijNij = numpy.array([[Xi02,Eta02], [Xi12,Eta12]])
                     # MijEijNij = numpy.array([[Xi01,Eta01], [Xi02,Eta02], [Xi12,Eta12]])
                     # MijResult0 = (-PhaseSlope[0] * cC) / (2*numpy.pi)
                     MijResult1 = (-PhaseSlope[1] * cC) / (2*numpy.pi)
                     MijResult2 = (-PhaseSlope[2] * cC) / (2*numpy.pi)
                     # MijResults = numpy.array([MijResult0, MijResult1, MijResult2])
                     MijResults = numpy.array([MijResult1, MijResult2])
                     (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
                     '''****** Getting constants A, B and H ******'''
                     W01 = numpy.nanmax( FitGauss01 )
                     W02 = numpy.nanmax( FitGauss02 )
                     W12 = numpy.nanmax( FitGauss12 )
                     WijResult01 = ((cF * Xi01 + cG * Eta01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi / cC))
                     WijResult02 = ((cF * Xi02 + cG * Eta02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi / cC))
                     WijResult12 = ((cF * Xi12 + cG * Eta12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi / cC))
                     WijResults = numpy.array([WijResult01, WijResult02, WijResult12])
                     WijEijNij = numpy.array([ [Xi01**2, Eta01**2, 2*Xi01*Eta01] , [Xi02**2, Eta02**2, 2*Xi02*Eta02] , [Xi12**2, Eta12**2, 2*Xi12*Eta12] ])
                     (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
                     VxVy = numpy.array([[cA,cH],[cH,cB]])
                     VxVyResults = numpy.array([-cF,-cG])
                     (Vmer,Vzon) = numpy.linalg.solve(VxVy, VxVyResults)
                     Vver =  -SPCMoments[1]*SPEED_OF_LIGHT/(2*radfreq)
                     error_code = 0
                     return Vzon, Vmer, Vver, error_code
             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.moments        :    Parameters per channel
                         self.dataOut.data_snr       :    SNR per channel
                 '''
                 def run(self, dataOut, proc_type=0):
                     absc = dataOut.abscissaList[:-1]
                     nChannel = dataOut.data_pre[0].shape[0]
                     nHei = dataOut.data_pre[0].shape[2]
                     data_param = numpy.zeros((nChannel, 4 + proc_type*3, nHei))
                     if proc_type == 1:
                         fwindow = numpy.zeros(absc.size) + 1
                         b=64
                         #b=16
                         fwindow[0:absc.size//2 - b] = 0
                         fwindow[absc.size//2 + b:] = 0
                         type1 = 1 # moments calculation & gaussean fitting
                         nProfiles = dataOut.nProfiles
                         nCohInt = dataOut.nCohInt
                         nIncohInt = dataOut.nIncohInt
                         M = numpy.power(numpy.array(1/(nProfiles * nCohInt) ,dtype='float32'),2)
                         N = numpy.array(M / nIncohInt,dtype='float32')
                         data = dataOut.data_pre[0] * N
                         #noise = dataOut.noise * N
                         noise = numpy.zeros(nChannel)
                         for ind in range(nChannel):
                             noise[ind] = self.__NoiseByChannel(nProfiles, nIncohInt, data[ind,:,:])
                         smooth=3
                     else:
                         data = dataOut.data_pre[0]
                         noise = dataOut.noise
                         fwindow = None
                         type1 = 0
                         nIncohInt = None
                         smooth=None
                     for ind in range(nChannel):
                         data_param[ind,:,:] = self.__calculateMoments( data[ind,:,:] , absc , noise[ind], nicoh=nIncohInt, smooth=smooth, type1=type1, fwindow=fwindow, id_ch=ind)
                     if proc_type == 1:
                         dataOut.moments = data_param[:,1:,:]
                         dataOut.data_dop = data_param[:,2]
                         dataOut.data_width = data_param[:,1]
                         dataOut.data_snr = data_param[:,0]
                         dataOut.data_pow = data_param[:,6]  # to compare with type0 proccessing
                         dataOut.spcpar=numpy.stack((dataOut.data_dop,dataOut.data_width,dataOut.data_snr, data_param[:,3], data_param[:,4],data_param[:,5]),axis=2)
                     else:
                         dataOut.moments = data_param[:,1:,:]
                         dataOut.data_snr = data_param[:,0]
                         dataOut.data_pow = data_param[:,1]
                         dataOut.data_dop = data_param[:,2]
                         dataOut.data_width = data_param[:,3]
                         dataOut.spcpar=numpy.stack((dataOut.data_dop,dataOut.data_width,dataOut.data_snr, dataOut.data_pow),axis=2)
                     return dataOut
                 def __calculateMoments(self, oldspec, oldfreq, n0, normFactor = 1,
                                        nicoh = None, graph = None, smooth = None, type1 = None, fwindow = None, snrth = None, dc = None, aliasing = None, oldfd = None, wwauto = None,id_ch=0):
                     def __GAUSSWINFIT1(A, flagPDER=0):
                         nonlocal truex, xvalid
                         nparams = 4
                         M=truex.size
                         mm=numpy.arange(M,dtype='f4')
                         delta = numpy.zeros(M,dtype='f4')
                         delta[0] = 1.0
                         Ts = numpy.array([1.0/(2*truex[0])],dtype='f4')[0]
                         jj = -1j
                         #if self.winauto is None: self.winauto = (1.0 - mm/M)
                         winauto = (1.0 - mm/M)
                         winauto = winauto/winauto.max()     # Normalized to 1
                         #ON_ERROR,2     # IDL sentence: Return to caller if an error occurs
                         A[0] = numpy.abs(A[0])
                         A[2] = numpy.abs(A[2])
                         A[3] = numpy.abs(A[3])
                         pi=numpy.array([numpy.pi],dtype='f4')[0]
                         if A[2] != 0:
                             Z = numpy.exp(-2*numpy.power((pi*A[2]*mm*Ts),2,dtype='f4')+jj*2*pi*A[1]*mm*Ts, dtype='c8')      # Get Z
                         else:
                             Z = mm*0.0
                             A[0] = 0.0
                         junkF = numpy.roll(2*fft(winauto*(A[0]*Z+A[3]*delta)).real - \
                                               winauto[0]*(A[0]+A[3]), M//2)                         # *M scale for fft not needed in python
                         F = junkF[xvalid]
                         if flagPDER == 0:       #NEED PARTIAL?
                             return F
                         PDER = numpy.zeros((M,nparams))   #YES, MAKE ARRAY.
                         PDER[:,0] = numpy.shift(2*(fft(winauto*Z)*M) - winauto[0], M/2)
                         PDER[:,1] = numpy.shift(2*(fft(winauto*jj*2*numpy.pi*mm*Ts*A[0]*Z)*M), M/2)
                         PDER[:,2] = numpy.shift(2*(fft(winauto*(-4*numpy.power(numpy.pi*mm*Ts,2)*A[2]*A[0]*Z))*M), M/2)
                         PDER[:,3] = numpy.shift(2*(fft(winauto*delta)*M) - winauto[0], M/2)
                         PDER = PDER[xvalid,:]
                         return F, PDER
                     def __curvefit_koki(y, a, Weights, FlagNoDerivative=1,
                                         itmax=20, tol=None):
                         #ON_ERROR,2 IDL SENTENCE: RETURN TO THE CALLER IF ERROR
                         if tol == None:
                             tol = numpy.array([1.e-3],dtype='f4')[0]
                         typ=a.dtype
                         double = 1 if typ == numpy.float64 else 0
                         if typ != numpy.float32:
                             a=a.astype(numpy.float32)       #Make params floating
                         # if we will be estimating partial derivates then compute machine precision
                         if FlagNoDerivative == 1:
                             res=numpy.MachAr(float_conv=numpy.float32)
                             eps=numpy.sqrt(res.eps)
                         nterms = a.size             # Number of parameters
                         nfree=numpy.array([numpy.size(y) - nterms],dtype='f4')[0]   # Degrees of freedom
                         if nfree <= 0: print('Curvefit - not enough data points.')
                         flambda= numpy.array([0.001],dtype='f4')[0]                         # Initial lambda
                         #diag=numpy.arange(nterms)*(nterms+1)       # Subscripta of diagonal elements
                         # Use diag method in python
                         converge=1
                         #Define the partial derivative array
                         PDER = numpy.zeros((nterms,numpy.size(y)),dtype='f8') if double == 1 else numpy.zeros((nterms,numpy.size(y)),dtype='f4')
                         for Niter in range(itmax):      #Iteration loop
                             if FlagNoDerivative == 1:
                                 #Evaluate function and estimate partial derivatives
                                 yfit = __GAUSSWINFIT1(a)
                                 for term in range(nterms):
                                     p=a.copy()      # Copy current parameters
                                     #Increment size for forward difference derivative
                                     inc = eps * abs(p[term])
                                     if inc == 0: inc = eps
                                     p[term] = p[term] + inc
                                     yfit1 = __GAUSSWINFIT1(p)
                                     PDER[term,:] = (yfit1-yfit)/inc
                             else:
                                 #The user's procedure will return partial derivatives
                                 yfit,PDER=__GAUSSWINFIT1(a, flagPDER=1)
                             beta = numpy.dot(PDER,(y-yfit)*Weights)
                             alpha = numpy.dot(PDER * numpy.tile(Weights,(nterms,1)), numpy.transpose(PDER))
                             # save current values of return parameters
                             sigma1 = numpy.sqrt( 1.0 / numpy.diag(alpha) )  # Current sigma.
                             sigma  = sigma1
                             chisq1 = numpy.sum(Weights*numpy.power(y-yfit,2,dtype='f4'),dtype='f4')/nfree     # Current chi squared.
                             chisq = chisq1
                             yfit1 = yfit
                             elev7=numpy.array([1.0e7],dtype='f4')[0]
                             compara =numpy.sum(abs(y))/elev7/nfree
                             done_early = chisq1 < compara
                             if done_early:
                                 chi2 = chisq         # Return chi-squared (chi2 obsolete-still works)
                                 if done_early: Niter -= 1
                                 #save_tp(chisq,Niter,yfit)
                                 return yfit, a, converge, sigma, chisq          # return result
                             #c = numpy.dot(c, c)    # this operator implemented at the next lines
                             c_tmp = numpy.sqrt(numpy.diag(alpha))
                             siz=len(c_tmp)
                             c=numpy.dot(c_tmp.reshape(siz,1),c_tmp.reshape(1,siz))
                             lambdaCount = 0
                             while True:
                                 lambdaCount += 1
                                 # Normalize alpha to have unit diagonal.
                                 array = alpha / c
                                 # Augment the diagonal.
                                 one=numpy.array([1.],dtype='f4')[0]
                                 numpy.fill_diagonal(array,numpy.diag(array)*(one+flambda))
                                 # Invert modified curvature matrix to find new parameters.
                                 try:
                                     array =  (1.0/array) if array.size == 1  else numpy.linalg.inv(array)
                                 except Exception as e:
                                     print(e)
                                     array[:]=numpy.NaN
                                 b = a + numpy.dot(numpy.transpose(beta),array/c) # New params
                                 yfit = __GAUSSWINFIT1(b) # Evaluate function
                                 chisq = numpy.sum(Weights*numpy.power(y-yfit,2,dtype='f4'),dtype='f4')/nfree # New chisq
                                 sigma = numpy.sqrt(numpy.diag(array)/numpy.diag(alpha)) # New sigma
                                 if (numpy.isfinite(chisq) == 0) or \
                                     (lambdaCount > 30 and chisq >= chisq1):
                                     # Reject changes made this iteration, use old values.
                                     yfit  = yfit1
                                     sigma = sigma1
                                     chisq = chisq1
                                     converge = 0
                                     #print('Failed to converge.')
                                     chi2 = chisq         # Return chi-squared (chi2 obsolete-still works)
                                     if done_early: Niter -= 1
                                     #save_tp(chisq,Niter,yfit)
                                     return yfit, a, converge, sigma, chisq, chi2          # return result
                                 ten=numpy.array([10.0],dtype='f4')[0]
                                 flambda *= ten      # Assume fit got worse
                                 if chisq <= chisq1:
                                     break
                             hundred=numpy.array([100.0],dtype='f4')[0]
                             flambda /= hundred
                             a=b                     # Save new parameter estimate.
                             if ((chisq1-chisq)/chisq1) <= tol: # Finished?
                                 chi2 = chisq         # Return chi-squared (chi2 obsolete-still works)
                                 if done_early: Niter -= 1
                                 #save_tp(chisq,Niter,yfit)
                                 return yfit, a, converge, sigma, chisq, chi2         # return result
                         converge = 0
                         chi2 = chisq
                         #print('Failed to converge.')
                         #save_tp(chisq,Niter,yfit)
                         return yfit, a, converge, sigma, chisq, chi2
                     if (nicoh is None): nicoh = 1
                     if (graph is None): graph = 0
                     if (smooth is None): smooth = 0
                     elif (self.smooth < 3): smooth = 0
                     if (type1 is None): type1 = 0
                     if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
                     if (snrth is None): snrth = -20.0
                     if (dc is None): dc = 0
                     if (aliasing is None): aliasing = 0
                     if (oldfd is None): oldfd = 0
                     if (wwauto is None): wwauto = 0
                     if (n0 < 1.e-20):   n0 = 1.e-20
                     xvalid = numpy.where(fwindow == 1)[0]
                     freq = oldfreq
                     truex = 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])
                     vec_n1 = numpy.empty(oldspec.shape[1])
                     vec_fp = numpy.empty(oldspec.shape[1])
                     vec_sigma_fd = numpy.empty(oldspec.shape[1])
                     norm = 1
                     for ind in range(oldspec.shape[1]):
                         spec = oldspec[:,ind]
                         if (smooth == 0):
                             spec2 = spec
                         else:
                             spec2 = scipy.ndimage.filters.uniform_filter1d(spec,size=smooth)
                         aux = spec2*fwindow
                         max_spec = aux.max()
                         m = aux.tolist().index(max_spec)
                         if hasattr(normFactor, "ndim"):
                             if normFactor.ndim >= 1:
                                 norm = normFactor[ind]
                         if m > 2 and m < oldfreq.size - 3:
                             newindex = m + numpy.array([-2,-1,0,1,2])
                             newfreq = numpy.arange(20)/20.0*(numpy.max(freq[newindex])-numpy.min(freq[newindex]))+numpy.min(freq[newindex])
                             #peakspec = SPLINE(,)
                             tck = interpolate.splrep(freq[newindex], spec2[newindex])
                             peakspec = interpolate.splev(newfreq, tck)
                             # max_spec = MAX(peakspec,)
                             max_spec = numpy.max(peakspec)
                             mnew = numpy.argmax(peakspec)
                             #fp = newfreq(mnew)
                             fp = newfreq[mnew]
                         else:
                             fp = freq[m]
                         if type1==0:
                             # Moments Estimation
                             bb = spec2[numpy.arange(m,spec2.size)]
                             bb = (bb<n0).nonzero()
                             bb = bb[0]
                             ss = spec2[numpy.arange(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.arange(int(m + bb0 - ss1 + 1)) + ss1
                             signal_power = ((spec2[valid] - n0) * fwindow[valid]).mean()    # D. Scipión added with correct definition
                             total_power = (spec2[valid] * fwindow[valid]).mean()            # D. Scipión added with correct definition
                             power = ((spec2[valid] - n0) * fwindow[valid]).sum()
                             fd = ((spec2[valid]- n0)*freq[valid] * fwindow[valid]).sum() / power
                             w = numpy.sqrt(((spec2[valid] - n0)*fwindow[valid]*(freq[valid]- fd)**2).sum() / power)
                             spec2 /=(norm)   #compensation for sats remove
                             snr = (spec2.mean()-n0)/n0
                             if (snr < 1.e-20): snr = 1.e-20
                             vec_power[ind] = total_power
                             vec_fd[ind] = fd
                             vec_w[ind] = w
                             vec_snr[ind] = snr
                         else:
                             # Noise by heights
                             n1, stdv = self.__get_noise2(spec, nicoh)
                             # Moments Estimation
                             bb = spec2[numpy.arange(m,spec2.size)]
                             bb = (bb<n1).nonzero()
                             bb = bb[0]
                             ss = spec2[numpy.arange(0,m + 1)]
                             ss = (ss<n1).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.arange(int(m + bb0 - ss1 + 1)) + ss1
                             power = ((spec[valid] - n1)*fwindow[valid]).sum()
                             fd = ((spec[valid]- n1)*freq[valid]*fwindow[valid]).sum()/power
                             try:
                                 w = numpy.sqrt(((spec[valid] - n1)*fwindow[valid]*(freq[valid]- fd)**2).sum()/power)
                             except:
                                 w = float("NaN")
                             snr = power/(n0*fwindow.sum())
                             if snr <  1.e-20: snr = 1.e-20
                             # Here start gaussean adjustment
                             if snr > numpy.power(10,0.1*snrth):
                                 a = numpy.zeros(4,dtype='f4')
                                 a[0] = snr * n0
                                 a[1] = fd
                                 a[2] = w
                                 a[3] = n0
                                 np = spec.size
                                 aold = a.copy()
                                 spec2 = spec.copy()
                                 oldxvalid = xvalid.copy()
                                 for i in range(2):
                                     ww = 1.0/(numpy.power(spec2,2)/nicoh)
                                     ww[np//2] = 0.0
                                     a = aold.copy()
                                     xvalid = oldxvalid.copy()
                                     #self.show_var(xvalid)
                                     gaussfn = __curvefit_koki(spec[xvalid], a, ww[xvalid])
                                     a = gaussfn[1]
                                     converge = gaussfn[2]
                                     xvalid = numpy.arange(np)
                                     spec2 = __GAUSSWINFIT1(a)
                                 xvalid = oldxvalid.copy()
                                 power = a[0] * np
                                 fd = a[1]
                                 sigma_fd = gaussfn[3][1]
                                 snr = max(power/ (max(a[3],n0) * len(oldxvalid)) * converge, 1e-20)
                                 w = numpy.abs(a[2])
                                 n1 = max(a[3], n0)
                                 #gauss_adj=[fd,w,snr,n1,fp,sigma_fd]
                             else:
                                 sigma_fd=numpy.nan # to avoid UnboundLocalError: local variable 'sigma_fd' referenced before assignment
                             vec_fd[ind] = fd
                             vec_w[ind] = w
                             vec_snr[ind] = snr
                             vec_n1[ind] = n1
                             vec_fp[ind] = fp
                             vec_sigma_fd[ind] = sigma_fd
                             vec_power[ind] = power  # to compare with type 0 proccessing
                     if type1==1:
                         return numpy.vstack((vec_snr,  vec_w, vec_fd, vec_n1, vec_fp, vec_sigma_fd, vec_power))   # snr and fd exchanged to compare doppler of both types
                     else:
                         return numpy.vstack((vec_snr, vec_power, vec_fd, vec_w))
                 def __get_noise2(self,POWER, fft_avg, TALK=0):
                     '''
                     Rutina para cálculo de ruido por alturas(n1). Similar a IDL
                     '''
                     SPECT_PTS = len(POWER)
                     fft_avg = fft_avg*1.0
                     NOMIT = 0
                     NN = SPECT_PTS - NOMIT
                     N  = NN//2
                     ARR = numpy.concatenate((POWER[0:N+1],POWER[N+NOMIT+1:SPECT_PTS]))
                     ARR = numpy.sort(ARR)
                     NUMS_MIN = (SPECT_PTS+7)//8
                     RTEST = (1.0+1.0/fft_avg)
                     SUM = 0.0
                     SUMSQ = 0.0
                     J = 0
                     for I in range(NN):
                         J = J + 1
                         SUM = SUM + ARR[I]
                         SUMSQ = SUMSQ + ARR[I]*ARR[I]
                         AVE = SUM*1.0/J
                         if J > NUMS_MIN:
                             if (SUMSQ*J <= RTEST*SUM*SUM): RNOISE = AVE
                         else:
                             if J == NUMS_MIN: RNOISE = AVE
                     if TALK == 1: print('Noise Power (2):%4.4f' %RNOISE)
                     stdv = numpy.sqrt(SUMSQ/J - numpy.power(SUM/J,2))
                     return RNOISE, stdv
                 def __get_noise1(self, power, fft_avg, TALK=0):
                     '''
                     Rutina para cálculo de ruido por alturas(n0). Similar a IDL
                     '''
                     num_pts = numpy.size(power)
                     #print('num_pts',num_pts)
                     #print('power',power.shape)
                     #print(power[256:267,0:2])
                     fft_avg = fft_avg*1.0
                     ind = numpy.argsort(power, axis=None, kind='stable')
                     #ind = numpy.argsort(numpy.reshape(power,-1))
                     #print(ind.shape)
                     #print(ind[0:11])
                     #print(numpy.reshape(power,-1)[ind[0:11]])
                     ARR = numpy.reshape(power,-1)[ind]
                     #print('ARR',len(ARR))
                     #print('ARR',ARR.shape)
                     NUMS_MIN = num_pts//10
                     RTEST = (1.0+1.0/fft_avg)
                     SUM = 0.0
                     SUMSQ = 0.0
                     J = 0
                     cont = 1
                     while cont == 1 and J < num_pts:
                         SUM = SUM + ARR[J]
                         SUMSQ = SUMSQ + ARR[J]*ARR[J]
                         J = J + 1
                         if J > NUMS_MIN:
                             if (SUMSQ*J <= RTEST*SUM*SUM):
                                 LNOISE = SUM*1.0/J
                             else:
                                 J = J - 1
                                 SUM = SUM - ARR[J]
                                 SUMSQ = SUMSQ - ARR[J]*ARR[J]
                                 cont = 0
                         else:
                             if J == NUMS_MIN: LNOISE = SUM*1.0/J
                     if TALK == 1: print('Noise Power (1):%8.8f' %LNOISE)
                     stdv = numpy.sqrt(SUMSQ/J - numpy.power(SUM/J,2))
                     return LNOISE, stdv
                 def __NoiseByChannel(self, num_prof, num_incoh, spectra,talk=0):
                     val_frq = numpy.arange(num_prof-2)+1
                     val_frq[(num_prof-2)//2:] = val_frq[(num_prof-2)//2:] + 1
                     junkspc = numpy.sum(spectra[val_frq,:], axis=1)
                     junkid = numpy.argsort(junkspc)
                     noisezone = val_frq[junkid[0:num_prof//2]]
                     specnoise = spectra[noisezone,:]
                     noise, stdvnoise = self.__get_noise1(specnoise,num_incoh)
                     if talk:
                         print('noise =', noise)
                     return noise
                 #------------------    Get SA Parameters    --------------------------
                 def GetSAParameters(self):
                     #SA en frecuencia
                     pairslist = self.dataOut.groupList
                     num_pairs = len(pairslist)
                     vel = self.dataOut.abscissaList
                     spectra = self.dataOut.data_pre
                     cspectra = self.dataIn.data_cspc
                     delta_v = vel[1] - vel[0]
                     #Calculating the power spectrum
                     spc_pow = numpy.sum(spectra, 3)*delta_v
                     #Normalizing Spectra
                     norm_spectra = spectra/spc_pow
                     #Calculating the norm_spectra at peak
                     max_spectra = numpy.max(norm_spectra, 3)
                     #Normalizing Cross Spectra
                     norm_cspectra = numpy.zeros(cspectra.shape)
                     for i in range(num_chan):
                         norm_cspectra[i,:,:] = cspectra[i,:,:]/numpy.sqrt(spc_pow[pairslist[i][0],:]*spc_pow[pairslist[i][1],:])
                     max_cspectra = numpy.max(norm_cspectra,2)
                     max_cspectra_index = numpy.argmax(norm_cspectra, 2)
                     for i in range(num_pairs):
                         cspc_par[i,:,:] = __calculateMoments(norm_cspectra)
                 #-------------------    Get Lags    ----------------------------------
             class JULIADriftsEstimation(Operation):
                 def __init__(self):
                     Operation.__init__(self)
                 def newtotal(self, data):
                     return numpy.nansum(data)
                 def data_filter(self, parm, snrth=-20, swth=20, wErrth=500):
                     Sz0 = parm.shape # Sz0: h,p
                     drift = parm[:,0]
                     sw = 2*parm[:,1]
                     snr = 10*numpy.log10(parm[:,2])
                     Sz = drift.shape # Sz: h
                     mask = numpy.ones((Sz[0]))
                     th=0
                     valid=numpy.where(numpy.isfinite(snr))
                     cvalid = len(valid[0])
                     if cvalid >= 1:
                         # Cálculo del ruido promedio de snr para el i-ésimo grupo de alturas
                         nbins = int(numpy.max(snr)-numpy.min(snr))+1 # bin size = 1, similar to IDL
                         h = numpy.histogram(snr,bins=nbins)
                         hist = h[0]
                         values = numpy.round_(h[1])
                         moda = values[numpy.where(hist == numpy.max(hist))]
                         indNoise = numpy.where(numpy.abs(snr - numpy.min(moda)) < 3)[0]
                         noise = snr[indNoise]
                         noise_mean = numpy.sum(noise)/len(noise)
                         # Cálculo de media de snr
                         med = numpy.median(snr)
                         # Establece el umbral de snr
                         if  noise_mean > med + 3:
                             th = med
                         else:
                             th = noise_mean + 3
                         # Establece máscara
                         novalid = numpy.where(snr <= th)[0]
                         mask[novalid] = numpy.nan
                     # Elimina datos que no sobrepasen el umbral: PARAMETRO
                     novalid = numpy.where(snr <= snrth)
                     cnovalid = len(novalid[0])
                     if cnovalid > 0:
                        mask[novalid] = numpy.nan
                     novalid = numpy.where(numpy.isnan(snr))
                     cnovalid = len(novalid[0])
                     if cnovalid > 0:
                         mask[novalid] = numpy.nan
                     new_parm = numpy.zeros((Sz0[0],Sz0[1]))
                     for h in range(Sz0[0]):
                         for p in range(Sz0[1]):
                             if numpy.isnan(mask[h]):
                                 new_parm[h,p]=numpy.nan
                             else:
                                 new_parm[h,p]=parm[h,p]
                     return new_parm, th
                 def run(self, dataOut, zenith, zenithCorrection,heights=None, statistics=0, otype=0):
                     dataOut.lat=-11.95
                     dataOut.lon=-76.87
                     nCh=dataOut.spcpar.shape[0]
                     nHei=dataOut.spcpar.shape[1]
                     nParam=dataOut.spcpar.shape[2]
                     # Selección de alturas
                     if not heights:
                         parm = numpy.zeros((nCh,nHei,nParam))
                         parm[:] = dataOut.spcpar[:]
                     else:
                         hei=dataOut.heightList
                         hvalid=numpy.where([hei >= heights[0]][0] & [hei <= heights[1]][0])[0]
                         nhvalid=len(hvalid)
                         dataOut.heightList = hei[hvalid]
                         parm = numpy.zeros((nCh,nhvalid,nParam))
                         parm[:] = dataOut.spcpar[:,hvalid,:]
                     # Primer filtrado: Umbral de SNR
                     for i in range(nCh):
                         parm[i,:,:] = self.data_filter(parm[i,:,:])[0]
                     zenith = numpy.array(zenith)
                     zenith -= zenithCorrection
                     zenith *= numpy.pi/180
                     alpha = zenith[0]
                     beta = zenith[1]
                     dopplerCH0 = parm[0,:,0]
                     dopplerCH1 = parm[1,:,0]
                     swCH0 = parm[0,:,1]
                     swCH1 = parm[1,:,1]
                     snrCH0 = 10*numpy.log10(parm[0,:,2])
                     snrCH1 = 10*numpy.log10(parm[1,:,2])
                     noiseCH0 = parm[0,:,3]
                     noiseCH1 = parm[1,:,3]
                     wErrCH0 = parm[0,:,5]
                     wErrCH1 = parm[1,:,5]
                     # Vertical and zonal calculation according to geometry
                     sinB_A = numpy.sin(beta)*numpy.cos(alpha) - numpy.sin(alpha)* numpy.cos(beta)
                     drift = -(dopplerCH0 * numpy.sin(beta) - dopplerCH1 * numpy.sin(alpha))/ sinB_A
                     zonal = (dopplerCH0 * numpy.cos(beta) - dopplerCH1 * numpy.cos(alpha))/ sinB_A
                     snr = (snrCH0 + snrCH1)/2
                     noise = (noiseCH0 + noiseCH1)/2
                     sw = (swCH0 + swCH1)/2
                     w_w_err= numpy.sqrt(numpy.power(wErrCH0 * numpy.sin(beta)/numpy.abs(sinB_A),2) + numpy.power(wErrCH1 * numpy.sin(alpha)/numpy.abs(sinB_A),2))
                     w_e_err= numpy.sqrt(numpy.power(wErrCH0 * numpy.cos(beta)/numpy.abs(-1*sinB_A),2) + numpy.power(wErrCH1 * numpy.cos(alpha)/numpy.abs(-1*sinB_A),2))
                     # for statistics150km
                     if statistics:
                         print('Implemented offline.')
                     if otype == 0:
                         winds = numpy.vstack((snr, drift, zonal, noise, sw, w_w_err, w_e_err)) # to process statistics drifts
                     elif otype == 3:
                         winds = numpy.vstack((snr, drift, zonal)) # to generic plot: 3 RTI's
                     elif otype == 4:
                         winds = numpy.vstack((snrCH0, drift, snrCH1, zonal)) # to generic plot: 4 RTI's
                     snr1 = numpy.vstack((snrCH0, snrCH1))
                     dataOut.data_output = winds
                     dataOut.data_snr = snr1
                     dataOut.utctimeInit = dataOut.utctime
                     dataOut.outputInterval = dataOut.timeInterval
                     try:
                         dataOut.flagNoData = numpy.all(numpy.isnan(dataOut.data_output[0]))  # NAN vectors are not written MADRIGAL CASE
                     except:
                         print("Check there is no Data")
                     return dataOut
             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
                     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 __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
             def fit_func( x, a0, a1, a2): #, a3, a4, a5):
                 z = (x - a1) / a2
                 y = a0 * numpy.exp(-z**2 / a2)  #+ a3 + a4 * x + a5 * x**2
                 return y
             class SpectralFitting(Operation):
                 '''
                     Function GetMoments()
                     Input:
                     Output:
                     Variables modified:
                 '''
                 isConfig = False
                 __dataReady = False
                 bloques =  None
                 bloque0 = None
-                index = 0
-                fint = 0
-                buffer = 0
-                buffer2 = 0
-                buffer3 = 0
                 def __init__(self):
                     Operation.__init__(self)
                     self.i=0
                     self.isConfig = False
+                def setup(self,nChan,nProf,nHei,nBlocks):
-                def setup(self,dataOut,groupList,path,file,filec):
                     self.__dataReady = False
-                    # new
+                    self.bloques = numpy.zeros([2, nProf, nHei,nBlocks], dtype= complex)
-                    self.nChannels         = dataOut.nChannels
+                    self.bloque0 = numpy.zeros([nChan, nProf, nHei, nBlocks])
-                    self.channels          = dataOut.channelList
-                    self.nHeights          = dataOut.heightList.size
-                    self.heights           = dataOut.heightList
-                    self.nProf             = dataOut.nProfiles
-                    self.nIncohInt         = dataOut.nIncohInt
-                    self.absc              = dataOut.abscissaList[:-1]
-                    #To be inserted as a parameter
-                    try:
-                        self.groupArray             = numpy.array(groupList)#groupArray = numpy.array([[0,1],[2,3]])
-                    except:
-                        print("Please insert groupList. Example (0,1),(2,3) format multilist")
-                    dataOut.groupList      = self.groupArray
-                    self.crosspairs        = dataOut.groupList
-                    self.nPairs            = len(self.crosspairs)
-                    self.nGroups                = self.groupArray.shape[0]
-                    #List of possible combinations
-                    self.listComb = itertools.combinations(numpy.arange(self.groupArray.shape[1]),2)
-                    self.indCross = numpy.zeros(len(list(self.listComb)), dtype = 'int')
-                    #Parameters Array
-                    dataOut.data_param     = None
-                    dataOut.data_paramC    = None
-                    dataOut.clean_num_aver = None
-                    dataOut.coh_num_aver   = None
-                    dataOut.tmp_spectra_i  = None
-                    dataOut.tmp_cspectra_i = None
-                    dataOut.tmp_spectra_c  = None
-                    dataOut.tmp_cspectra_c = None
-                    dataOut.index          = None
-                    if path != None:
-                        sys.path.append(path)
-                    self.library           = importlib.import_module(file)
-                    if filec != None:
-                        self.weightf       = importlib.import_module(filec)
-                    #Set constants
-                    self.constants         = self.library.setConstants(dataOut)
-                    dataOut.constants      = self.constants
-                    self.M                 = dataOut.normFactor
-                    self.N                 = dataOut.nFFTPoints
-                    self.ippSeconds        = dataOut.ippSeconds
-                    self.K                 = dataOut.nIncohInt
-                    self.pairsArray        = numpy.array(dataOut.pairsList)
-                    self.snrth             = 20
                 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 (smooth is None): smooth = 0
                     elif (self.smooth < 3): smooth = 0
                     if (type1 is None): type1 = 0
                     if (fwindow is None): fwindow = numpy.zeros(oldfreq.size) + 1
                     if (snrth is None): snrth = -3
                     if (dc is None): dc = 0
                     if (aliasing is None): aliasing = 0
                     if (oldfd is None): oldfd = 0
                     if (wwauto is 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])
                     oldspec = numpy.ma.masked_invalid(oldspec)
                     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[list(range(m,spec2.size))]
                         bb = (bb<n0).nonzero()
                         bb = bb[0]
                         ss = spec2[list(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(list(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) :
+                        # if (snr < 1.e-20) :
-                            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
+                  #def __DiffCoherent(self,snrth, spectra, cspectra, nProf, heights,nChan, nHei, nPairs, channels, noise, crosspairs):
                 def __DiffCoherent(self, spectra, cspectra, dataOut, noise, snrth, coh_th, hei_th):
+                    #import matplotlib.pyplot as plt
                     nProf = dataOut.nProfiles
                     heights = dataOut.heightList
                     nHei = len(heights)
                     channels = dataOut.channelList
                     nChan = len(channels)
                     crosspairs = dataOut.groupList
                     nPairs = len(crosspairs)
                     #Separar espectros incoherentes de coherentes snr > 20 dB'
                     snr_th = 10**(snrth/10.0)
                     my_incoh_spectra = numpy.zeros([nChan, nProf,nHei], dtype='float')
                     my_incoh_cspectra = numpy.zeros([nPairs,nProf, nHei], dtype='complex')
                     my_incoh_aver = numpy.zeros([nChan, nHei])
                     my_coh_aver = numpy.zeros([nChan, nHei])
                     coh_spectra = numpy.zeros([nChan, nProf, nHei], dtype='float')
                     coh_cspectra = numpy.zeros([nPairs, nProf, nHei], dtype='complex')
                     coh_aver = numpy.zeros([nChan, nHei])
                     incoh_spectra = numpy.zeros([nChan, nProf, nHei], dtype='float')
                     incoh_cspectra = numpy.zeros([nPairs, nProf, nHei], dtype='complex')
                     incoh_aver = numpy.zeros([nChan, nHei])
                     power = numpy.sum(spectra, axis=1)
                     if coh_th == None : coh_th = numpy.array([0.75,0.65,0.15]) # 0.65
                     if hei_th == None : hei_th = numpy.array([60,300,650])
                     for ic in range(nPairs):
                         pair = crosspairs[ic]
                         #si el SNR es mayor que el SNR threshold los datos se toman coherentes
                         s_n0 = power[pair[0],:]/noise[pair[0]]
                         s_n1 = power[pair[1],:]/noise[pair[1]]
                         valid1 =(s_n0>=snr_th).nonzero()
                         valid2 = (s_n1>=snr_th).nonzero()
                         valid1 =  numpy.array(valid1[0])
                         valid2 =  numpy.array(valid2[0])
                         valid = valid1
                         for iv in range(len(valid2)):
                             indv = numpy.array((valid1 == valid2[iv]).nonzero())
                             if len(indv[0]) == 0 :
                                valid =  numpy.concatenate((valid,valid2[iv]), axis=None)
                         if len(valid)>0:
                             my_coh_aver[pair[0],valid]=1
                             my_coh_aver[pair[1],valid]=1
                         # si la coherencia es mayor a la coherencia threshold los datos se toman
                         coh = numpy.squeeze(numpy.nansum(cspectra[ic,:,:], axis=0)/numpy.sqrt(numpy.nansum(spectra[pair[0],:,:], axis=0)*numpy.nansum(spectra[pair[1],:,:], axis=0)))
                         for ih in range(len(hei_th)):
                             hvalid = (heights>hei_th[ih]).nonzero()
                             hvalid = hvalid[0]
                             if len(hvalid)>0:
                                 valid = (numpy.absolute(coh[hvalid])>coh_th[ih]).nonzero()
                                 valid = valid[0]
                                 if len(valid)>0:
                                     my_coh_aver[pair[0],hvalid[valid]] =1
                                     my_coh_aver[pair[1],hvalid[valid]] =1
                         coh_echoes = (my_coh_aver[pair[0],:] == 1).nonzero()
                         incoh_echoes = (my_coh_aver[pair[0],:] != 1).nonzero()
                         incoh_echoes = incoh_echoes[0]
                         if len(incoh_echoes) > 0:
                             my_incoh_spectra[pair[0],:,incoh_echoes] = spectra[pair[0],:,incoh_echoes]
                             my_incoh_spectra[pair[1],:,incoh_echoes] = spectra[pair[1],:,incoh_echoes]
                             my_incoh_cspectra[ic,:,incoh_echoes] = cspectra[ic,:,incoh_echoes]
                             my_incoh_aver[pair[0],incoh_echoes] = 1
                             my_incoh_aver[pair[1],incoh_echoes] = 1
                     for ic in range(nPairs):
                         pair = crosspairs[ic]
                         valid1 =(my_coh_aver[pair[0],:]==1 ).nonzero()
                         valid2 = (my_coh_aver[pair[1],:]==1).nonzero()
                         valid1 = numpy.array(valid1[0])
                         valid2 = numpy.array(valid2[0])
                         valid = valid1
                         for iv in range(len(valid2)):
                             indv = numpy.array((valid1 == valid2[iv]).nonzero())
                             if len(indv[0]) == 0 :
                                valid =  numpy.concatenate((valid,valid2[iv]), axis=None)
                         valid1 =(my_coh_aver[pair[0],:] !=1 ).nonzero()
                         valid2 = (my_coh_aver[pair[1],:] !=1).nonzero()
                         valid1 = numpy.array(valid1[0])
                         valid2 = numpy.array(valid2[0])
                         incoh_echoes = valid1
                         for iv in range(len(valid2)):
                             indv = numpy.array((valid1 == valid2[iv]).nonzero())
                             if len(indv[0]) == 0 :
                                incoh_echoes = numpy.concatenate(( incoh_echoes,valid2[iv]), axis=None)
                         if len(valid)>0:
                             coh_spectra[pair[0],:,valid] = spectra[pair[0],:,valid]
                             coh_spectra[pair[1],:,valid] = spectra[pair[1],:,valid]
                             coh_cspectra[ic,:,valid] = cspectra[ic,:,valid]
                             coh_aver[pair[0],valid]=1
                             coh_aver[pair[1],valid]=1
                         if len(incoh_echoes)>0:
                             incoh_spectra[pair[0],:,incoh_echoes] = spectra[pair[0],:,incoh_echoes]
                             incoh_spectra[pair[1],:,incoh_echoes] = spectra[pair[1],:,incoh_echoes]
                             incoh_cspectra[ic,:,incoh_echoes] = cspectra[ic,:,incoh_echoes]
                             incoh_aver[pair[0],incoh_echoes]=1
                             incoh_aver[pair[1],incoh_echoes]=1
                     return  my_incoh_spectra ,my_incoh_cspectra,my_incoh_aver,my_coh_aver, incoh_spectra, coh_spectra, incoh_cspectra, coh_cspectra, incoh_aver, coh_aver
                 def __CleanCoherent(self,snrth, spectra, cspectra, coh_aver,dataOut, noise,clean_coh_echoes,index):
+                    #import matplotlib.pyplot as plt
                     nProf = dataOut.nProfiles
                     heights = dataOut.heightList
                     nHei = len(heights)
                     channels = dataOut.channelList
                     nChan = len(channels)
                     crosspairs = dataOut.groupList
                     nPairs = len(crosspairs)
                     absc = dataOut.abscissaList[:-1]
                     data_param = numpy.zeros((nChan, 4, spectra.shape[2]))
                     clean_coh_spectra = spectra.copy()
                     clean_coh_cspectra = cspectra.copy()
                     clean_coh_aver = coh_aver.copy()
                     spwd_th=[10,6]  #spwd_th[0] --> For satellites ; spwd_th[1] --> For special events like SUN.
                     coh_th = 0.75
                     rtime0 = [6,18] # periodo sin ESF
                     rtime1 = [10.5,13.5] # periodo con alta coherencia y alto ancho espectral (esperado): SOL.
                     time = index*5./60 # en base a 5 min de proceso
                     if clean_coh_echoes == 1 :
                        for ind in range(nChan):
                           data_param[ind,:,:] = self.__calculateMoments( spectra[ind,:,:] , absc , noise[ind] )
                        spwd = data_param[:,3]
                     #  SPECB_JULIA,header=anal_header,jspectra=spectra,vel=velocities,hei=heights, num_aver=1, mode_fit=0,smoothing=smoothing,jvelr=velr,jspwd=spwd,jsnr=snr,jnoise=noise,jstdvnoise=stdvnoise
                   # para obtener spwd
                        for ic in range(nPairs):
                           pair = crosspairs[ic]
                           coh = numpy.squeeze(numpy.sum(cspectra[ic,:,:], axis=1)/numpy.sqrt(numpy.sum(spectra[pair[0],:,:], axis=1)*numpy.sum(spectra[pair[1],:,:], axis=1)))
                           for ih in range(nHei) :
                     # Considering heights higher than 200km in order to avoid removing phenomena like EEJ.
                              if heights[ih] >= 200 and coh_aver[pair[0],ih] == 1 and coh_aver[pair[1],ih] == 1 :
                       # Checking coherence
                                 if (numpy.abs(coh[ih]) <= coh_th) or (time >= rtime0[0] and time <= rtime0[1]) :
                         # Checking spectral widths
                                    if (spwd[pair[0],ih] > spwd_th[0]) or (spwd[pair[1],ih] > spwd_th[0]) :
                           # satelite
                                       clean_coh_spectra[pair,ih,:] = 0.0
                                       clean_coh_cspectra[ic,ih,:] =  0.0
                                       clean_coh_aver[pair,ih] = 0
                                    else :
                                         if ((spwd[pair[0],ih] < spwd_th[1]) or (spwd[pair[1],ih] < spwd_th[1])) :
                             # Especial event like sun.
                                            clean_coh_spectra[pair,ih,:] = 0.0
                                            clean_coh_cspectra[ic,ih,:] =  0.0
                                            clean_coh_aver[pair,ih] = 0
                     return clean_coh_spectra, clean_coh_cspectra, clean_coh_aver
                 def CleanRayleigh(self,dataOut,spectra,cspectra,save_drifts):
                     rfunc = cspectra.copy()
                     n_funct = len(rfunc[0,:,0,0])
                     val_spc = spectra*0.0
                     val_cspc = cspectra*0.0
                     in_sat_spectra = spectra.copy()
                     in_sat_cspectra = cspectra.copy()
                     min_hei = 200
                     nProf = dataOut.nProfiles
                     heights = dataOut.heightList
                     nHei = len(heights)
                     channels = dataOut.channelList
                     nChan = len(channels)
                     crosspairs = dataOut.groupList
                     nPairs = len(crosspairs)
                     hval=(heights >= min_hei).nonzero()
                     ih=hval[0]
                     for ih in range(hval[0][0],nHei):
                         for ifreq in range(nProf):
                             for ii in range(n_funct):
                                 func2clean = 10*numpy.log10(numpy.absolute(rfunc[:,ii,ifreq,ih]))
                                 val = (numpy.isfinite(func2clean)==True).nonzero()
                                 if len(val)>0:
                                    min_val = numpy.around(numpy.amin(func2clean)-2) #> (-40)
                                    if min_val <= -40 : min_val = -40
                                    max_val = numpy.around(numpy.amax(func2clean)+2) #< 200
                                    if max_val >= 200 : max_val = 200
                                    step = 1
-                                   #Getting bins and the histogram
+                                        #Getting bins and the histogram
                                    x_dist = min_val + numpy.arange(1 + ((max_val-(min_val))/step))*step
                                    y_dist,binstep = numpy.histogram(func2clean,bins=range(int(min_val),int(max_val+2),step))
                                    mean = numpy.sum(x_dist * y_dist) / numpy.sum(y_dist)
                                    sigma = numpy.sqrt(numpy.sum(y_dist * (x_dist - mean)**2) / numpy.sum(y_dist))
                                    parg = [numpy.amax(y_dist),mean,sigma]
                                    try :
                                        gauss_fit, covariance = curve_fit(fit_func, x_dist, y_dist,p0=parg)
                                        mode = gauss_fit[1]
                                        stdv = gauss_fit[2]
                                    except:
                                        mode = mean
                                        stdv = sigma
                                    #Removing echoes greater than mode + 3*stdv
                                    factor_stdv = 2.5
                                    noval = (abs(func2clean - mode)>=(factor_stdv*stdv)).nonzero()
                                    if len(noval[0]) > 0:
                                         novall = ((func2clean - mode) >= (factor_stdv*stdv)).nonzero()
                                         cross_pairs = crosspairs[ii]
                                             #Getting coherent echoes which are removed.
                                         if len(novall[0]) > 0:
                                             val_spc[novall[0],cross_pairs[0],ifreq,ih] = 1
                                             val_spc[novall[0],cross_pairs[1],ifreq,ih] = 1
                                             val_cspc[novall[0],ii,ifreq,ih] = 1
                                             #Removing coherent from ISR data
                                         spectra[noval,cross_pairs[0],ifreq,ih] = numpy.nan
                                         spectra[noval,cross_pairs[1],ifreq,ih] = numpy.nan
                                         cspectra[noval,ii,ifreq,ih] = numpy.nan
+            #
+                                #no sale es para savedrifts >2
+                        '''             channels = dataOut.channelList
+                                        cross_pairs = dataOut.groupList
+                                        vcross0 = (cross_pairs[0] == channels[ii]).nonzero()
+                                        vcross1 = (cross_pairs[1] == channels[ii]).nonzero()
+                                        vcross = numpy.concatenate((vcross0,vcross1),axis=None)
+                                        #Getting coherent echoes which are removed.
+                                        if len(novall) > 0:
+                                                #val_spc[novall,ii,ifreq,ih] = 1
+                                             val_spc[ii,ifreq,ih,novall] = 1
+                                             if len(vcross) > 0:
+                                                val_cspc[vcross,ifreq,ih,novall] = 1
+                                        #Removing coherent from ISR data.
+                                        spectra[ii,ifreq,ih,noval] = numpy.nan
+                                        if len(vcross) > 0:
+                                            cspectra[vcross,ifreq,ih,noval] = numpy.nan
+                        '''
                         #Getting average of the spectra and cross-spectra from incoherent echoes.
                     out_spectra = numpy.zeros([nChan,nProf,nHei], dtype=float) #+numpy.nan
                     out_cspectra = numpy.zeros([nPairs,nProf,nHei], dtype=complex) #+numpy.nan
                     for ih in range(nHei):
                         for ifreq in range(nProf):
                             for ich in range(nChan):
                                 tmp = spectra[:,ich,ifreq,ih]
                                 valid = (numpy.isfinite(tmp[:])==True).nonzero()
                                 if len(valid[0]) >0 :
                                    out_spectra[ich,ifreq,ih] = numpy.nansum(tmp)/len(valid[0])
                             for icr in range(nPairs):
                                 tmp = numpy.squeeze(cspectra[:,icr,ifreq,ih])
                                 valid = (numpy.isfinite(tmp)==True).nonzero()
                                 if len(valid[0]) > 0:
                                     out_cspectra[icr,ifreq,ih] = numpy.nansum(tmp)/len(valid[0])
                         #Removing fake coherent echoes (at least 4 points around the point)
                     val_spectra = numpy.sum(val_spc,0)
                     val_cspectra = numpy.sum(val_cspc,0)
                     val_spectra = self.REM_ISOLATED_POINTS(val_spectra,4)
                     val_cspectra = self.REM_ISOLATED_POINTS(val_cspectra,4)
                     for i in range(nChan):
                         for j in range(nProf):
                             for k in range(nHei):
                                 if numpy.isfinite(val_spectra[i,j,k]) and val_spectra[i,j,k] < 1 :
                                     val_spc[:,i,j,k] = 0.0
                     for i in range(nPairs):
                         for j in range(nProf):
                             for k in range(nHei):
                                 if numpy.isfinite(val_cspectra[i,j,k]) and val_cspectra[i,j,k] < 1 :
                                     val_cspc[:,i,j,k] = 0.0
+            #         val_spc = numpy.reshape(val_spc, (len(spectra[:,0,0,0]),nProf*nHei*nChan))
+            #         if numpy.isfinite(val_spectra)==str(True):
+            #            noval = (val_spectra<1).nonzero()
+            #            if len(noval) > 0:
+            #                val_spc[:,noval] = 0.0
+            #                val_spc = numpy.reshape(val_spc, (149,nChan,nProf,nHei))
+                        #val_cspc = numpy.reshape(val_spc, (149,nChan*nHei*nProf))
+                        #if numpy.isfinite(val_cspectra)==str(True):
+                         #   noval = (val_cspectra<1).nonzero()
+                          #  if len(noval) > 0:
+                           #     val_cspc[:,noval] = 0.0
+                            #    val_cspc = numpy.reshape(val_cspc, (149,nChan,nProf,nHei))
                     tmp_sat_spectra = spectra.copy()
                     tmp_sat_spectra = tmp_sat_spectra*numpy.nan
                     tmp_sat_cspectra = cspectra.copy()
                     tmp_sat_cspectra = tmp_sat_cspectra*numpy.nan
                     val = (val_spc > 0).nonzero()
                     if len(val[0]) > 0:
                             tmp_sat_spectra[val] = in_sat_spectra[val]
                     val = (val_cspc > 0).nonzero()
                     if len(val[0]) > 0:
                             tmp_sat_cspectra[val] = in_sat_cspectra[val]
                         #Getting average of the spectra and cross-spectra from incoherent echoes.
                     sat_spectra = numpy.zeros((nChan,nProf,nHei), dtype=float)
                     sat_cspectra = numpy.zeros((nPairs,nProf,nHei), dtype=complex)
                     for ih in range(nHei):
                         for ifreq in range(nProf):
                             for ich in range(nChan):
                                 tmp = numpy.squeeze(tmp_sat_spectra[:,ich,ifreq,ih])
                                 valid = (numpy.isfinite(tmp)).nonzero()
                                 if len(valid[0]) > 0:
                                     sat_spectra[ich,ifreq,ih] = numpy.nansum(tmp)/len(valid[0])
                             for icr in range(nPairs):
                                 tmp = numpy.squeeze(tmp_sat_cspectra[:,icr,ifreq,ih])
                                 valid = (numpy.isfinite(tmp)).nonzero()
                                 if len(valid[0]) > 0:
                                     sat_cspectra[icr,ifreq,ih] = numpy.nansum(tmp)/len(valid[0])
                     return out_spectra, out_cspectra,sat_spectra,sat_cspectra
                 def REM_ISOLATED_POINTS(self,array,rth):
                     if rth == None : rth = 4
                     num_prof = len(array[0,:,0])
                     num_hei = len(array[0,0,:])
                     n2d = len(array[:,0,0])
                     for ii in range(n2d) :
                       tmp = array[ii,:,:]
                       tmp = numpy.reshape(tmp,num_prof*num_hei)
                       indxs1 = (numpy.isfinite(tmp)==True).nonzero()
                       indxs2 = (tmp > 0).nonzero()
                       indxs1 = (indxs1[0])
                       indxs2 = indxs2[0]
                       indxs = None
                       for iv in range(len(indxs2)):
                             indv = numpy.array((indxs1 == indxs2[iv]).nonzero())
                             if len(indv[0]) > 0  :
                                indxs =  numpy.concatenate((indxs,indxs2[iv]), axis=None)
                       indxs = indxs[1:]
                       if len(indxs) < 4 :
                         array[ii,:,:] = 0.
                         return
-                      xpos = numpy.mod(indxs ,num_hei)
+                      xpos = numpy.mod(indxs ,num_prof)
-                      ypos = (indxs / num_hei)
+                      ypos = (indxs / num_prof)
                       sx = numpy.argsort(xpos) # Ordering respect to "x" (time)
                       xpos = xpos[sx]
                       ypos = ypos[sx]
-                    # *********************************** Cleaning isolated points **********************************
+               # *********************************** Cleaning isolated points **********************************
                       ic = 0
                       while True :
                         r = numpy.sqrt(list(numpy.power((xpos[ic]-xpos),2)+ numpy.power((ypos[ic]-ypos),2)))
                         no_coh1 = (numpy.isfinite(r)==True).nonzero()
                         no_coh2 = (r <= rth).nonzero()
                         no_coh1 = numpy.array(no_coh1[0])
                         no_coh2 = numpy.array(no_coh2[0])
                         no_coh = None
                         for iv in range(len(no_coh2)):
                             indv = numpy.array((no_coh1 == no_coh2[iv]).nonzero())
                             if len(indv[0]) > 0  :
                                no_coh =  numpy.concatenate((no_coh,no_coh2[iv]), axis=None)
                         no_coh = no_coh[1:]
                         if len(no_coh) < 4 :
                            xpos[ic] = numpy.nan
                            ypos[ic] = numpy.nan
                         ic = ic + 1
                         if  (ic == len(indxs)) :
                             break
                       indxs = (numpy.isfinite(list(xpos))==True).nonzero()
                       if len(indxs[0]) < 4 :
                          array[ii,:,:] = 0.
                          return
                       xpos = xpos[indxs[0]]
                       ypos = ypos[indxs[0]]
                       for i in range(0,len(ypos)):
                 	      ypos[i]=int(ypos[i])
                       junk = tmp
                       tmp = junk*0.0
                       tmp[list(xpos + (ypos*num_hei))] = junk[list(xpos + (ypos*num_hei))]
                       array[ii,:,:] = numpy.reshape(tmp,(num_prof,num_hei))
                     return array
                 def moments(self,doppler,yarray,npoints):
                     ytemp = yarray
                     val = (ytemp > 0).nonzero()
                     val = val[0]
                     if len(val) == 0 : val = range(npoints-1)
                     ynew = 0.5*(ytemp[val[0]]+ytemp[val[len(val)-1]])
                     ytemp[len(ytemp):] = [ynew]
                     index = 0
                     index = numpy.argmax(ytemp)
                     ytemp = numpy.roll(ytemp,int(npoints/2)-1-index)
                     ytemp = ytemp[0:npoints-1]
                     fmom = numpy.sum(doppler*ytemp)/numpy.sum(ytemp)+(index-(npoints/2-1))*numpy.abs(doppler[1]-doppler[0])
                     smom = numpy.sum(doppler*doppler*ytemp)/numpy.sum(ytemp)
                     return [fmom,numpy.sqrt(smom)]
+                # **********************************************************************************************
+                index = 0
+                fint = 0
+                buffer = 0
+                buffer2 = 0
+                buffer3 = 0
                 def run(self, dataOut, getSNR = True, path=None, file=None, groupList=None, filec=None,coh_th=None, hei_th=None,taver=None,proc=None,nhei=None,nprofs=None,ipp=None,channelList=None):
-                    if not self.isConfig:
+                    if not numpy.any(proc):
-                        self.setup(dataOut = dataOut,groupList=groupList,path=path,file=file,filec=filec)
-                        self.isConfig = True
+                        nChannels = dataOut.nChannels
+                        nHeights= dataOut.heightList.size
-                    if not numpy.any(proc):
+                        nProf = dataOut.nProfiles
-                        if numpy.any(taver):
+                        if numpy.any(taver): taver=int(taver)
-                            taver         = int(taver)
+                        else : taver = 5
-                        else :
+                        tini=time.localtime(dataOut.utctime)
-                            taver         = 5
+                        if (tini.tm_min % taver) == 0 and (tini.tm_sec < 5 and self.fint==0):
-                        tini              = time.localtime(dataOut.utctime)
-                        if (tini.tm_min % taver) == 0 and (tini.tm_sec < 5 and self.fint==0):
+                            self.index = 0
-                            self.index   = 0
+                            jspc = self.buffer
-                            jspc         = self.buffer
+                            jcspc = self.buffer2
-                            jcspc        = self.buffer2
+                            jnoise = self.buffer3
-                            jnoise       = self.buffer3
+                            self.buffer = dataOut.data_spc
-                            self.buffer  = dataOut.data_spc
                             self.buffer2 = dataOut.data_cspc
                             self.buffer3 = dataOut.noise
-                            self.fint    = 1
+                            self.fint = 1
                             if numpy.any(jspc) :
-                                jspc     = numpy.reshape(jspc  ,(int(len(jspc)  /    self.nChannels)   ,    self.nChannels   ,self.nProf,self.nHeights ))
+                                jspc= numpy.reshape(jspc,(int(len(jspc)/nChannels),nChannels,nProf,nHeights))
-                                jcspc    = numpy.reshape(jcspc ,(int(len(jcspc) /int(self.nChannels/2)),int(self.nChannels/2),self.nProf,self.nHeights ))
+                                jcspc= numpy.reshape(jcspc,(int(len(jcspc)/int(nChannels/2)),int(nChannels/2),nProf,nHeights))
-                                jnoise   = numpy.reshape(jnoise,(int(len(jnoise)/    self.nChannels)   ,    self.nChannels))
+                                jnoise= numpy.reshape(jnoise,(int(len(jnoise)/nChannels),nChannels))
                             else:
                                 dataOut.flagNoData = True
                                 return dataOut
                         else :
-                            if (tini.tm_min % taver) == 0 :
+                            if (tini.tm_min % taver) == 0 : self.fint = 1
-                                self.fint = 1
+                            else : self.fint = 0
-                            else :
-                                self.fint = 0
                             self.index += 1
                             if numpy.any(self.buffer):
                                 self.buffer = numpy.concatenate((self.buffer,dataOut.data_spc), axis=0)
                                 self.buffer2 = numpy.concatenate((self.buffer2,dataOut.data_cspc), axis=0)
                                 self.buffer3 = numpy.concatenate((self.buffer3,dataOut.noise), axis=0)
                             else:
                                 self.buffer = dataOut.data_spc
                                 self.buffer2 = dataOut.data_cspc
                                 self.buffer3 = dataOut.noise
                             dataOut.flagNoData = True
                             return dataOut
+                        if path != None:
+                            sys.path.append(path)
+                        self.library = importlib.import_module(file)
+                        if filec != None:
+                            self.weightf = importlib.import_module(filec)
+                            #self.weightf = importlib.import_module('weightfit')
+                        #To be inserted as a parameter
+                        groupArray = numpy.array(groupList)
+                        #groupArray = numpy.array([[0,1],[2,3]])
+                        dataOut.groupList = groupArray
+                        nGroups = groupArray.shape[0]
+                        nChannels = dataOut.nChannels
+                        nHeights = dataOut.heightList.size
-                        jnoise              = jnoise/self.N# creo que falta dividirlo entre N
+                            #Parameters Array
-                        noise               = numpy.nansum(jnoise,axis=0)#/len(jnoise)
+                        dataOut.data_param = None
-                        index               = tini.tm_hour*12+tini.tm_min/taver
+                        dataOut.data_paramC = None
-                        dataOut.index       = index
+                        dataOut.clean_num_aver = None
-                        jspc                = jspc/self.N/self.N
+                        dataOut.coh_num_aver = None
-                        jcspc               = jcspc/self.N/self.N
+                        dataOut.tmp_spectra_i = None
+                        dataOut.tmp_cspectra_i = None
+                        dataOut.tmp_spectra_c = None
+                        dataOut.tmp_cspectra_c = None
+                        dataOut.sat_spectra = None
+                        dataOut.sat_cspectra = None
+                        dataOut.index = None
+                            #Set constants
+                        constants = self.library.setConstants(dataOut)
+                        dataOut.constants = constants
+                        M = dataOut.normFactor
+                        N = dataOut.nFFTPoints
+                        ippSeconds = dataOut.ippSeconds
+                        K = dataOut.nIncohInt
+                        pairsArray = numpy.array(dataOut.pairsList)
+                        snrth= 15
+                        spectra = dataOut.data_spc
+                        cspectra = dataOut.data_cspc
+                        nProf = dataOut.nProfiles
+                        heights = dataOut.heightList
+                        nHei = len(heights)
+                        channels = dataOut.channelList
+                        nChan = len(channels)
+                        nIncohInt = dataOut.nIncohInt
+                        crosspairs = dataOut.groupList
+                        noise = dataOut.noise
+                        jnoise = jnoise/N
+                        noise = numpy.nansum(jnoise,axis=0)#/len(jnoise)
+                        #print("NOISE-> ", 10*numpy.log10(noise))
+                        power = numpy.sum(spectra, axis=1)
+                        nPairs = len(crosspairs)
+                        absc = dataOut.abscissaList[:-1]
+                        #print('para escribir h5 ',dataOut.paramInterval)
+                        if not self.isConfig:
+                            self.isConfig = True
+                        index = tini.tm_hour*12+tini.tm_min/taver
+                        dataOut.index= index
+                        jspc = jspc/N/N
+                        jcspc = jcspc/N/N
                         tmp_spectra,tmp_cspectra,sat_spectra,sat_cspectra = self.CleanRayleigh(dataOut,jspc,jcspc,2)
-                        jspectra                                          = tmp_spectra  * len(jspc[:,0,0,0])
+                        jspectra = tmp_spectra*len(jspc[:,0,0,0])
-                        jcspectra                                         = tmp_cspectra * len(jspc[:,0,0,0])
+                        jcspectra = tmp_cspectra*len(jspc[:,0,0,0])
+                        my_incoh_spectra ,my_incoh_cspectra,my_incoh_aver,my_coh_aver, incoh_spectra, coh_spectra, incoh_cspectra, coh_cspectra, incoh_aver, coh_aver = self.__DiffCoherent(jspectra, jcspectra, dataOut, noise, snrth,coh_th, hei_th)
-                        my_incoh_spectra ,my_incoh_cspectra,my_incoh_aver,my_coh_aver, incoh_spectra, coh_spectra, incoh_cspectra, coh_cspectra, incoh_aver, coh_aver = self.__DiffCoherent(jspectra, jcspectra, dataOut, noise, self.snrth,coh_th, hei_th)
+                        clean_coh_spectra, clean_coh_cspectra, clean_coh_aver = self.__CleanCoherent(snrth, coh_spectra, coh_cspectra, coh_aver, dataOut, noise,1,index)
-                        clean_coh_spectra, clean_coh_cspectra, clean_coh_aver                                                                                         = self.__CleanCoherent(self.snrth, coh_spectra, coh_cspectra, coh_aver, dataOut, noise,1,index)
+                        dataOut.data_spc = incoh_spectra
+                        dataOut.data_cspc = incoh_cspectra
-                        dataOut.data_spc                                      = incoh_spectra
+                        dataOut.sat_spectra = sat_spectra
-                        dataOut.data_cspc                                     = incoh_cspectra
+                        dataOut.sat_cspectra = sat_cspectra
-                        clean_num_aver                                        = incoh_aver    * len(jspc[:,0,0,0])
+                            #   dataOut.data_spc = tmp_spectra
-                        coh_num_aver                                          = clean_coh_aver* len(jspc[:,0,0,0])
+                            #   dataOut.data_cspc = tmp_cspectra
-                        dataOut.clean_num_aver                                = clean_num_aver
-                        dataOut.coh_num_aver                                  = coh_num_aver
+                        clean_num_aver = incoh_aver*len(jspc[:,0,0,0])
+                        coh_num_aver = clean_coh_aver*len(jspc[:,0,0,0])
+                            #   clean_num_aver = (numpy.zeros([nChan, nHei])+1)*len(jspc[:,0,0,0])
+                            #   coh_num_aver = numpy.zeros([nChan, nHei])*0*len(jspc[:,0,0,0])
+                        dataOut.clean_num_aver = clean_num_aver
+                        dataOut.coh_num_aver = coh_num_aver
+                        dataOut.tmp_spectra_i = incoh_spectra
+                        dataOut.tmp_cspectra_i = incoh_cspectra
+                        dataOut.tmp_spectra_c = clean_coh_spectra
+                        dataOut.tmp_cspectra_c = clean_coh_cspectra
+                            #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()
+                            norm = dataOut.nProfiles * dataOut.nIncohInt * dataOut.nCohInt * dataOut.windowOfFilter #* jspc.shape[0]
+                            dataOut.data_snr = self.__getSNR(dataOut.data_spc[listChannels,:,:], noise[listChannels], norm=norm)
                     else:
+                        if numpy.any(taver): taver=int(taver)
+                        else : taver = 5
+                        tini=time.localtime(dataOut.utctime)
+                        index = tini.tm_hour*12+tini.tm_min/taver
                         clean_num_aver = dataOut.clean_num_aver
                         coh_num_aver = dataOut.coh_num_aver
                         dataOut.data_spc = dataOut.tmp_spectra_i
                         dataOut.data_cspc = dataOut.tmp_cspectra_i
                         clean_coh_spectra = dataOut.tmp_spectra_c
                         clean_coh_cspectra = dataOut.tmp_cspectra_c
                         jspectra = dataOut.data_spc+clean_coh_spectra
                         nHeights = len(dataOut.heightList) # nhei
                         nProf = int(dataOut.nProfiles)
                         dataOut.nProfiles = nProf
                         dataOut.data_param = None
                         dataOut.data_paramC = None
                         dataOut.code = numpy.array([[-1.,-1.,1.],[1.,1.,-1.]])
+                        #dataOut.paramInterval = 2.0
                         #M=600
                         #N=200
                         dataOut.flagDecodeData=True
                         M = int(dataOut.normFactor)
                         N = int(dataOut.nFFTPoints)
                         dataOut.nFFTPoints = N
                         dataOut.nIncohInt= int(dataOut.nIncohInt)
                         dataOut.nProfiles = int(dataOut.nProfiles)
                         dataOut.nCohInt = int(dataOut.nCohInt)
+                        #print('sale',dataOut.nProfiles,dataOut.nHeights)
                         #dataOut.nFFTPoints=nprofs
                         #dataOut.normFactor = nprofs
                         dataOut.channelList = channelList
+                        nChan = len(channelList)
                         #dataOut.ippFactor=1
                         #ipp = ipp/150*1.e-3
                         vmax = (300000000/49920000.0/2) / (dataOut.ippSeconds)
                         #dataOut.ippSeconds=ipp
                         absc = vmax*( numpy.arange(nProf,dtype='float')-nProf/2.)/nProf
+                        #print('sale 2',dataOut.ippSeconds,M,N)
+                        # print('Empieza procesamiento offline')
                         if path != None:
                             sys.path.append(path)
                         self.library = importlib.import_module(file)
                         constants = self.library.setConstants(dataOut)
                         constants['M'] = M
                         dataOut.constants = constants
+                        if filec != None:
-                    #List of possible combinations
+                            self.weightf = importlib.import_module(filec)
-                    listComb = itertools.combinations(numpy.arange(self.groupArray.shape[1]),2)
+                    groupArray = numpy.array(groupList)
+                    dataOut.groupList = groupArray
+                    nGroups = groupArray.shape[0]
+            #List of possible combinations
+                    listComb = itertools.combinations(numpy.arange(groupArray.shape[1]),2)
                     indCross = numpy.zeros(len(list(listComb)), dtype = 'int')
                     if dataOut.data_paramC is None:
-                        dataOut.data_paramC = numpy.zeros((self.nGroups*4, self.nHeights ,2))*numpy.nan
+                        dataOut.data_paramC = numpy.zeros((nGroups*4, nHeights,2))*numpy.nan
-                    for i in range(self.nGroups):
+                        dataOut.data_snr1_i = numpy.zeros((nGroups*2, nHeights))*numpy.nan
-                        coord = self.groupArray[i,:]
+                        # dataOut.smooth_i = numpy.zeros((nGroups*2, nHeights))*numpy.nan
+                    for i in range(nGroups):
+                        coord = groupArray[i,:]
                         #Input data array
-                        data  = dataOut.data_spc[coord,:,:]/(self.M*self.N)
+                        data = dataOut.data_spc[coord,:,:]/(M*N)
-                        data  = data.reshape((data.shape[0]*data.shape[1],data.shape[2]))
+                        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]])
+                            pairsSel = numpy.array([coord[x],coord[y]])
-                            indCross[ind] = int(numpy.where(numpy.all(self.pairsArray == pairsSel, axis = 1))[0][0])
+                            indCross[ind] = int(numpy.where(numpy.all(pairsArray == pairsSel, axis = 1))[0][0])
-                            ind          += 1
+                            ind += 1
-                        dataCross = dataOut.data_cspc[indCross,:,:]/(self.M*self.N)
+                        dataCross = dataOut.data_cspc[indCross,:,:]/(M*N)
                         dataCross = dataCross**2
-                        nhei      = self.nHeights
+                        nhei = nHeights
-                        poweri = numpy.sum(dataOut.data_spc[:,1:self.nProf-0,:],axis=1)/clean_num_aver[:,:]
+                        poweri = numpy.sum(dataOut.data_spc[:,1:nProf-0,:],axis=1)/clean_num_aver[:,:]
                         if i == 0 : my_noises = numpy.zeros(4,dtype=float)
-                        n0i = numpy.nanmin(poweri[0+i*2,0:nhei-0])/(self.nProf-1)
+                        n0i = numpy.nanmin(poweri[0+i*2,0:nhei-0])/(nProf-1)
-                        n1i = numpy.nanmin(poweri[1+i*2,0:nhei-0])/(self.nProf-1)
+                        n1i = numpy.nanmin(poweri[1+i*2,0:nhei-0])/(nProf-1)
                         n0 = n0i
                         n1=  n1i
                         my_noises[2*i+0] = n0
                         my_noises[2*i+1] = n1
-                        snrth = -15.0 # -4 -16 -25
+                        snrth = -13.0 # -4 -16 -25
                         snrth = 10**(snrth/10.0)
-                        jvelr = numpy.zeros(self.nHeights, dtype = 'float')
+                        jvelr = numpy.zeros(nHeights, dtype = 'float')
+                        #snr0 = numpy.zeros(nHeights, dtype = 'float')
+                        #snr1 = numpy.zeros(nHeights, dtype = 'float')
                         hvalid = [0]
-                        coh2 = abs(dataOut.data_cspc[i,1:self.nProf,:])**2/(dataOut.data_spc[0+i*2,1:self.nProf-0,:]*dataOut.data_spc[1+i*2,1:self.nProf-0,:])
+                        coh2 = abs(dataOut.data_cspc[i,1:nProf,:])**2/(dataOut.data_spc[0+i*2,1:nProf-0,:]*dataOut.data_spc[1+i*2,1:nProf-0,:])
-                        for h in range(self.nHeights):
+                        for h in range(nHeights):
                             smooth = clean_num_aver[i+1,h]
-                            signalpn0 = (dataOut.data_spc[i*2,1:(self.nProf-0),h])/smooth
+                            signalpn0 = (dataOut.data_spc[i*2,1:(nProf-0),h])/smooth
-                            signalpn1 = (dataOut.data_spc[i*2+1,1:(self.nProf-0),h])/smooth
+                            signalpn1 = (dataOut.data_spc[i*2+1,1:(nProf-0),h])/smooth
                             signal0 = signalpn0-n0
                             signal1 = signalpn1-n1
-                            snr0 = numpy.sum(signal0/n0)/(self.nProf-1)
+                            snr0 = numpy.sum(signal0/n0)/(nProf-1)
-                            snr1 = numpy.sum(signal1/n1)/(self.nProf-1)
+                            snr1 = numpy.sum(signal1/n1)/(nProf-1)
+                            #jmax0 = MAX(signal0,maxp0)
+                            #jmax1 = MAX(signal1,maxp1)
                             gamma = coh2[:,h]
                             indxs = (numpy.isfinite(list(gamma))==True).nonzero()
                             if len(indxs) >0:
                                if numpy.nanmean(gamma) > 0.07:
                                   maxp0 = numpy.argmax(signal0*gamma)
                                   maxp1 = numpy.argmax(signal1*gamma)
                                   #print('usa gamma',numpy.nanmean(gamma))
                                else:
                                   maxp0 = numpy.argmax(signal0)
                                   maxp1 = numpy.argmax(signal1)
-                               jvelr[h] = (self.absc[maxp0]+self.absc[maxp1])/2.
+                               jvelr[h] = (absc[maxp0]+absc[maxp1])/2.
-                            else: jvelr[h] = self.absc[0]
+                            else: jvelr[h] = absc[0]
                             if snr0 > 0.1 and snr1 > 0.1: hvalid = numpy.concatenate((hvalid,h), axis=None)
                             #print(maxp0,absc[maxp0],snr0,jvelr[h])
                         if len(hvalid)> 1: fd0 = numpy.median(jvelr[hvalid[1:]])*-1
                         else: fd0 = numpy.nan
-                        for h in range(self.nHeights):
+                        #print(fd0)
+                        for h in range(nHeights):
                             d = data[:,h]
                             smooth = clean_num_aver[i+1,h] #dataOut.data_spc[:,1:nProf-0,:]
-                            signalpn0 = (dataOut.data_spc[i*2,1:(self.nProf-0),h])/smooth
+                            signalpn0 = (dataOut.data_spc[i*2,1:(nProf-0),h])/smooth
-                            signalpn1 = (dataOut.data_spc[i*2+1,1:(self.nProf-0),h])/smooth
+                            signalpn1 = (dataOut.data_spc[i*2+1,1:(nProf-0),h])/smooth
                             signal0 = signalpn0-n0
                             signal1 = signalpn1-n1
-                            snr0 = numpy.sum(signal0/n0)/(self.nProf-1)
+                            snr0 = numpy.sum(signal0/n0)/(nProf-1)
-                            snr1 = numpy.sum(signal1/n1)/(self.nProf-1)
+                            snr1 = numpy.sum(signal1/n1)/(nProf-1)
                             if snr0 > snrth and snr1 > snrth and clean_num_aver[i+1,h] > 0 :
-                                #Covariance Matrix
+                            #Covariance Matrix
                                 D = numpy.diag(d**2)
                                 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
                                 diagD = numpy.zeros(256)
+                                #Dinv=numpy.linalg.inv(D)
+                                #L=numpy.linalg.cholesky(Dinv)
                                 try:
                                    Dinv=numpy.linalg.inv(D)
                                    L=numpy.linalg.cholesky(Dinv)
                                 except:
                                    Dinv = D*numpy.nan
                                    L= D*numpy.nan
                                 LT=L.T
                                 dp = numpy.dot(LT,d)
-                                #Initial values
+                            #Initial values
                                 data_spc = dataOut.data_spc[coord,:,h]
                                 w = data_spc/data_spc
                                 if filec != None:
                                    w = self.weightf.weightfit(w,tini.tm_year,tini.tm_yday,index,h,i)
-                                if (h>6)and(error1[3]<25):
+                                if (h>6) and (error1[3]<25):
                                     p0 = dataOut.data_param[i,:,h-1].copy()
+                                    #print('usa anterior')
                                 else:
-                                    p0 = numpy.array(self.library.initialValuesFunction(data_spc*w, self.constants))# sin el i(data_spc, constants, i)
+                                    p0 = numpy.array(self.library.initialValuesFunction(data_spc*w, constants))# sin el i(data_spc, constants, i)
                                 p0[3] = fd0
                                 if filec != None:
                                    p0 = self.weightf.Vrfit(p0,tini.tm_year,tini.tm_yday,index,h,i)
+                                #if index == 175 and i==1 and h>=27 and h<=35: p0[3]=30
+                                #if h >= 6 and i==1 and h<= 10: print(p0)
                                 try:
-                                    #Least Squares
+                                #Least Squares
-                                    minp,covp,infodict,mesg,ier = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,self.constants),full_output=True)
+                                    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))
+                                #minp,covp = optimize.leastsq(self.__residFunction,p0,args=(dp,LT,constants))
-                                    #Chi square error
+                                #Chi square error
-                                    error0 = numpy.sum(infodict['fvec']**2)/(2*self.N)
+                                    error0 = numpy.sum(infodict['fvec']**2)/(2*N)
-                                    #Error with Jacobian
+                                #Error with Jacobian
-                                    error1 = self.library.errorFunction(minp,self.constants,LT)
+                                    error1 = self.library.errorFunction(minp,constants,LT)
+                                    #if h >= 0 and h<= 10 and i ==0: print(p0,minp,error1)
+                                    #if i>=0 and h>=0: print(index,h,minp[3])
+            #                         print self.__residFunction(p0,dp,LT, constants)
+            #                         print infodict['fvec']
+            #                         print self.__residFunction(minp,dp,LT,constants)
                                 except:
                                     minp = p0*numpy.nan
                                     error0 = numpy.nan
                                     error1 = p0*numpy.nan
+            #                     s_sq = (self.__residFunction(minp,dp,LT,constants)).sum()/(len(dp)-len(p0))
+            #                     covp = covp*s_sq
+            #                     error = []
+            #                     for ip in range(len(minp)):
+            #                         try:
+            #                             error.append(numpy.absolute(covp[ip][ip])**0.5)
+            #                         except:
+            #                             error.append( 0.00 )
+                                #if i==1 and h==11 and index == 139: print(p0, minp,data_spc)
                             else :
                                 data_spc = dataOut.data_spc[coord,:,h]
-                                p0 = numpy.array(self.library.initialValuesFunction(data_spc, self.constants))
+                                p0 = numpy.array(self.library.initialValuesFunction(data_spc, constants))
                                 minp = p0*numpy.nan
                                 error0 = numpy.nan
                                 error1 = p0*numpy.nan
                             if dataOut.data_param is None:
-                                dataOut.data_param = numpy.zeros((self.nGroups, p0.size, self.nHeights ))*numpy.nan
+                                dataOut.data_param = numpy.zeros((nGroups, p0.size, nHeights))*numpy.nan
-                                dataOut.data_error = numpy.zeros((self.nGroups, p0.size + 1, self.nHeights ))*numpy.nan
+                                dataOut.data_error = numpy.zeros((nGroups, p0.size + 1, nHeights))*numpy.nan
                             dataOut.data_error[i,:,h] = numpy.hstack((error0,error1))
                             dataOut.data_param[i,:,h] = minp
+                            dataOut.data_snr1_i[i*2,h] = numpy.sum(signalpn0/(nProf-1))/n0
-                        for ht in range(self.nHeights-1) :
+                            dataOut.data_snr1_i[i*2+1,h] = numpy.sum(signalpn1/(nProf-1))/n1
+                            #dataOut.smooth_i[i*2,h] = clean_num_aver[i+1,h]
+                            #print(fd0,dataOut.data_param[i,3,h])
+                        #print(fd0,dataOut.data_param[i,3,:])
+                        for ht in range(nHeights-1) :
                             smooth = coh_num_aver[i+1,ht] #datc[0,ht,0,beam]
                             dataOut.data_paramC[4*i,ht,1] = smooth
-                            signalpn0 = (clean_coh_spectra[i*2  ,1:(self.nProf-0),ht])/smooth #coh_spectra
+                            signalpn0 = (clean_coh_spectra[i*2  ,1:(nProf-0),ht])/smooth #coh_spectra
-                            signalpn1 = (clean_coh_spectra[i*2+1,1:(self.nProf-0),ht])/smooth
+                            signalpn1 = (clean_coh_spectra[i*2+1,1:(nProf-0),ht])/smooth
                             val0 = (signalpn0 > 0).nonzero()
                             val0 = val0[0]
-                            if len(val0) == 0 : val0_npoints = self.nProf
+                            if len(val0) == 0 : val0_npoints = nProf
                             else : val0_npoints = len(val0)
                             val1 = (signalpn1 > 0).nonzero()
                             val1 = val1[0]
-                            if len(val1) == 0 : val1_npoints = self.nProf
+                            if len(val1) == 0 : val1_npoints = nProf
                             else : val1_npoints = len(val1)
                             dataOut.data_paramC[0+4*i,ht,0] = numpy.sum((signalpn0/val0_npoints))/n0
                             dataOut.data_paramC[1+4*i,ht,0] = numpy.sum((signalpn1/val1_npoints))/n1
                             signal0 = (signalpn0-n0)
                             vali = (signal0 < 0).nonzero()
                             vali = vali[0]
                             if len(vali) > 0 : signal0[vali] = 0
                             signal1 = (signalpn1-n1)
                             vali = (signal1 < 0).nonzero()
                             vali = vali[0]
                             if len(vali) > 0 : signal1[vali] = 0
-                            snr0 = numpy.sum(signal0/n0)/(self.nProf-1)
+                            snr0 = numpy.sum(signal0/n0)/(nProf-1)
-                            snr1 = numpy.sum(signal1/n1)/(self.nProf-1)
+                            snr1 = numpy.sum(signal1/n1)/(nProf-1)
-                            doppler = self.absc[1:]
+                            doppler = absc[1:]
                             if snr0 >= snrth and snr1 >= snrth and smooth :
                                 signalpn0_n0 = signalpn0
                                 signalpn0_n0[val0] = signalpn0[val0] - n0
-                                mom0 = self.moments(doppler,signalpn0-n0,self.nProf)
+                                mom0 = self.moments(doppler,signalpn0-n0,nProf)
                                 signalpn1_n1 = signalpn1
                                 signalpn1_n1[val1] = signalpn1[val1] - n1
-                                mom1 = self.moments(doppler,signalpn1_n1,self.nProf)
+                                mom1 = self.moments(doppler,signalpn1_n1,nProf)
                                 dataOut.data_paramC[2+4*i,ht,0] = (mom0[0]+mom1[0])/2.
                                 dataOut.data_paramC[3+4*i,ht,0] = (mom0[1]+mom1[1])/2.
+                                #dataOut.data_snr1_c[i*2,ht] = numpy.sum(signalpn0/(nProf-1))/n0
+                                #dataOut.data_snr1_c[i*2+1,ht] = numpy.sum(signalpn1/(nProf-1))/n1
                     dataOut.data_spc = jspectra
-                    dataOut.spc_noise = my_noises*self.nProf*self.M
+                    dataOut.spc_noise = my_noises*nProf*M
-                    if numpy.any(proc): dataOut.spc_noise = my_noises*self.nProf*self.M
-                    if getSNR:
+                    if numpy.any(proc): dataOut.spc_noise = my_noises*nProf*M
-                        listChannels = self.groupArray.reshape((self.groupArray.size))
+                    if 0:
+                        listChannels = groupArray.reshape((groupArray.size))
                         listChannels.sort()
-                        # TEST
+                        norm = dataOut.nProfiles * dataOut.nIncohInt * dataOut.nCohInt * dataOut.windowOfFilter
-                        noise_C = numpy.zeros(self.nChannels)
+                        dataOut.data_snr = self.__getSNR(dataOut.data_spc[listChannels,:,:], my_noises[listChannels], norm=norm)
-                        noise_C = dataOut.getNoise()
+                    #print(dataOut.data_snr1_i)
-                        #print("noise_C",noise_C)
+                    # Adding coherent echoes from possible satellites.
-                        dataOut.data_snr = self.__getSNR(dataOut.data_spc[listChannels,:,:],noise_C/(600.0*1.15))# PRUEBA *nProf*M
+                     #sat_spectra = numpy.zeros((nChan,nProf,nHei), dtype=float)
-                        #dataOut.data_snr = self.__getSNR(dataOut.data_spc[listChannels,:,:], noise_C[listChannels])# PRUEBA *nProf*M
+                 #sat_spectra = sat_spectra[*,*,anal_header.channels]
-                    dataOut.flagNoData = False
+                    isat_spectra = numpy.zeros([2,int(nChan/2),nProf,nhei], dtype=float)
+                    sat_fits = numpy.zeros([4,nhei], dtype=float)
+                    noises = my_noises/nProf
+                    #nchan2 = int(nChan/2)
+                    for beam in range(int(nChan/2)-0) :
+                      n0 = noises[2*beam]
+                      n1 = noises[2*beam+1]
+                      isat_spectra[0:2,beam,:,:] = dataOut.sat_spectra[2*beam +0:2*beam+2 ,:,:]
+                      for ht in range(nhei-1) :
+                         signalpn0 = isat_spectra[0,beam,:,ht]
+                         signalpn0 = numpy.reshape(signalpn0,nProf)
+                         signalpn1 = isat_spectra[1,beam,:,ht]
+                         signalpn1 = numpy.reshape(signalpn1,nProf)
+                         cval0 = len((signalpn0 > 0).nonzero()[0])
+                         if cval0 == 0 : val0_npoints = nProf
+                         else: val0_npoints = cval0
+                         cval1 = len((signalpn1 > 0).nonzero()[0])
+                         if cval1 == 0 : val1_npoints = nProf
+                         else: val1_npoints = cval1
+                         sat_fits[0+2*beam,ht] = numpy.sum(signalpn0/(val0_npoints*nProf))/n0
+                         sat_fits[1+2*beam,ht] = numpy.sum(signalpn1/(val1_npoints*nProf))/n1
+                    dataOut.sat_fits = sat_fits
                     return dataOut
                 def __residFunction(self, p, dp, LT, constants):
                     fm = self.library.modelFunction(p, constants)
                     fmp=numpy.dot(LT,fm)
                     return  dp-fmp
-                def __getSNR(self, z, noise):
+                def __getSNR(self, z, noise, norm=1):
+                    # normFactor = dataOut.nProfiles * dataOut.nIncohInt * dataOut.nCohInt * pwcode * dataOut.windowOfFilter
                     avg = numpy.average(z, axis=1)
+                    #noise /= norm
                     SNR = (avg.T-noise)/noise
+                    # SNR = avg.T/noise
+                    # print("Noise: ", 10*numpy.log10(noise))
+                    # print("SNR: ", SNR)
+                    # print("SNR: ", 10*numpy.log10(SNR))
                     SNR = SNR.T
                     return SNR
                 def __chisq(self, 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 = list(range(len(phi)))
                     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((A.shape[0],velRadial.shape[1]))
                     velUVW[:,:] = numpy.dot(A,velRadial)
                     return velUVW
                 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 'dirCosx' in kwargs and 'dirCosy' in kwargs:
                         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 'horizontalOnly' in kwargs:
                         horizontalOnly = kwargs['horizontalOnly']
                     else:   horizontalOnly = False
                     if 'correctFactor' in kwargs:
                         correctFactor = kwargs['correctFactor']
                     else:   correctFactor = 1
                     if 'channelList' in kwargs:
                         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
                 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 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 'correctFactor' in kwargs:
                         correctFactor = kwargs['correctFactor']
                     else:
                         correctFactor = 1
                     groupList = kwargs['groupList']
                     pairs_ccf = groupList[1]
                     tau = kwargs['tau']
                     _lambda = kwargs['_lambda']
                     #Cross Correlation pairs obtained
                     indtau = tau.shape[0]/2
                     tau1 = tau[:indtau,:]
                     tau2 = tau[indtau:-1,:]
                     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
                     #---------------------------------------------------------------------
                     winds[2,:] = self.__calculateVelVer(phase1, lagTRange, _lambda)
                     winds = correctFactor*winds
                     return winds
                 def __checkTime(self, currentTime, paramInterval, outputInterval):
                     dataTime = currentTime + paramInterval
                     deltaTime = dataTime - self.__initime
                     if deltaTime >= outputInterval or deltaTime < 0:
                         self.__dataReady = True
                     return
                 def techniqueMeteors(self, arrayMeteor, meteorThresh, heightMin, heightMax):
                     '''
                     Function that implements winds estimation technique with detected meteors.
                     Input:    Detected meteors, Minimum meteor quantity to wind estimation
                     Output:    Winds estimation (Zonal and Meridional)
                     Parameters affected:    Winds
                     '''
                     #Settings
                     nInt = (heightMax - heightMin)/2
                     nInt = int(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)
                             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,:]
                         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.moments
                     if numpy.any(dataOut.abscissaList):
                         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
                         kwargs['groupList'] = dataOut.groupList
                         kwargs['tau'] = dataOut.data_param
                         kwargs['_lambda'] = dataOut.C/dataOut.frequency
                         dataOut.data_output = self.techniqueSA(kwargs)
                         dataOut.utctimeInit = dataOut.utctime
                         dataOut.outputInterval = dataOut.timeInterval
                     elif technique == 'Meteors':
                         dataOut.flagNoData = True
                         self.__dataReady = False
                         if 'nHours' in kwargs:
                             nHours = kwargs['nHours']
                         else:
                             nHours = 1
                         if 'meteorsPerBin' in kwargs:
                             meteorThresh = kwargs['meteorsPerBin']
                         else:
                             meteorThresh = 6
                         if 'hmin' in kwargs:
                             hmin = kwargs['hmin']
                         else:   hmin = 70
                         if 'hmax' in kwargs:
                             hmax = kwargs['hmax']
                         else:   hmax = 110
                         dataOut.outputInterval = nHours*3600
                         if self.__isConfig == False:
                             #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:
                             self.__buffer = dataOut.data_param
                             self.__firstdata = copy.copy(dataOut)
                         else:
                             self.__buffer = numpy.vstack((self.__buffer, dataOut.data_param))
                         self.__checkTime(dataOut.utctime, dataOut.paramInterval, dataOut.outputInterval) #Check if the buffer is ready
                         if self.__dataReady:
                             dataOut.utctimeInit = self.__initime
                             self.__initime += dataOut.outputInterval #to erase time offset
                             dataOut.data_output, dataOut.heightList = self.techniqueMeteors(self.__buffer, meteorThresh, hmin, hmax)
                             dataOut.flagNoData = False
                             self.__buffer = None
                     elif technique == 'Meteors1':
                         dataOut.flagNoData = True
                         self.__dataReady = False
                         if 'nMins' in kwargs:
                             nMins = kwargs['nMins']
                         else: nMins = 20
                         if 'rx_location' in kwargs:
                             rx_location = kwargs['rx_location']
                         else: rx_location = [(0,1),(1,1),(1,0)]
                         if 'azimuth' in kwargs:
                             azimuth = kwargs['azimuth']
                         else: azimuth = 51.06
                         if 'dfactor' in kwargs:
                             dfactor = kwargs['dfactor']
                         if 'mode' in kwargs:
                             mode = kwargs['mode']
                         if 'theta_x' in kwargs:
                             theta_x = kwargs['theta_x']
                         if 'theta_y' in kwargs:
                             theta_y = kwargs['theta_y']
                         else: mode = 'SA'
                         #Borrar luego esto
                         if dataOut.groupList is 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
                             #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:
                             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 dataOut
             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 = list(range(len(phi)))
                     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,:]
                         vali= (numpy.isfinite(y1)==True).nonzero()
                         y1=y1[vali]
                         x = x[vali]
                         f1 = interpolate.interp1d(x,y1,kind = 'cubic',bounds_error=False)
                         x1 = heiRang1
                         y11 = f1(x1)
                         y2 = SNR[i,:]
                         x = heiRang*math.cos(phi[i])
                         vali= (y2 != -1).nonzero()
                         y2 = y2[vali]
                         x = x[vali]
                         f2 = interpolate.interp1d(x,y2,kind = 'cubic',bounds_error=False)
                         y21 = f2(x1)
                         velRadial1[i,:] = y11
                         SNR1[i,:] = y21
                     return heiRang1, velRadial1, SNR1
                 def run(self, dataOut, zenith, zenithCorrection,fileDrifts):
+                    dataOut.lat = -11.95
-                    dataOut.lat=-11.95
+                    dataOut.lon = -76.87
-                    dataOut.lon=-76.87
+                    dataOut.spcst = 0.00666
+                    dataOut.pl = 0.0003
+                    dataOut.cbadn = 3
+                    dataOut.inttms = 300
+                    dataOut.azw = -115.687
+                    dataOut.elw = 86.1095
+                    dataOut.aze = 130.052
+                    dataOut.ele = 87.6558
+                    dataOut.jro14 = numpy.log10(dataOut.spc_noise[0]/dataOut.normFactor)
+                    dataOut.jro15 = numpy.log10(dataOut.spc_noise[1]/dataOut.normFactor)
+                    dataOut.jro16 = numpy.log10(dataOut.spc_noise[2]/dataOut.normFactor)
+                    dataOut.nwlos = numpy.log10(dataOut.spc_noise[3]/dataOut.normFactor)
                     heiRang = dataOut.heightList
                     velRadial = dataOut.data_param[:,3,:]
                     velRadialm = dataOut.data_param[:,2:4,:]*-1
                     rbufc=dataOut.data_paramC[:,:,0]
                     ebufc=dataOut.data_paramC[:,:,1]
-                    SNR = dataOut.data_snr
+                    SNR = dataOut.data_snr1_i
+                    rbufi = dataOut.data_snr1_i
                     velRerr = dataOut.data_error[:,4,:]
+                    range1 = dataOut.heightList
+                    nhei = len(range1)
+                    sat_fits = dataOut.sat_fits
                     channels = dataOut.channelList
                     nChan = len(channels)
                     my_nbeams = nChan/2
                     if my_nbeams == 2:
                        moments=numpy.vstack(([velRadialm[0,:]],[velRadialm[0,:]],[velRadialm[1,:]],[velRadialm[1,:]]))
                     else :
                        moments=numpy.vstack(([velRadialm[0,:]],[velRadialm[0,:]]))
                     dataOut.moments=moments
+                    #Incoherent
+                    smooth_w = dataOut.clean_num_aver[0,:]
+                    chisq_w = dataOut.data_error[0,0,:]
+                    p_w0 = rbufi[0,:]
+                    p_w1 = rbufi[1,:]
                     # Coherent
                     smooth_wC = ebufc[0,:]
                     p_w0C = rbufc[0,:]
                     p_w1C = rbufc[1,:]
                     w_wC = rbufc[2,:]*-1 #*radial_sign(radial EQ 1)
                     t_wC = rbufc[3,:]
+                    val = (numpy.isfinite(p_w0)==False).nonzero()
+                    p_w0[val]=0
+                    val = (numpy.isfinite(p_w1)==False).nonzero()
+                    p_w1[val]=0
+                    val = (numpy.isfinite(p_w0C)==False).nonzero()
+                    p_w0C[val]=0
+                    val = (numpy.isfinite(p_w1C)==False).nonzero()
+                    p_w1C[val]=0
+                    val = (numpy.isfinite(smooth_w)==False).nonzero()
+                    smooth_w[val]=0
+                    val = (numpy.isfinite(smooth_wC)==False).nonzero()
+                    smooth_wC[val]=0
+                    #p_w0 = (p_w0*smooth_w+p_w0C*smooth_wC)/(smooth_w+smooth_wC)
+                    #p_w1 = (p_w1*smooth_w+p_w1C*smooth_wC)/(smooth_w+smooth_wC)
+                    if len(sat_fits) >0 :
+                      p_w0C = p_w0C + sat_fits[0,:]
+                      p_w1C = p_w1C + sat_fits[1,:]
                     if my_nbeams == 1:
                        w = velRadial[0,:]
                        winds = velRadial.copy()
                        w_err = velRerr[0,:]
-                       snr1 = 10*numpy.log10(SNR[0])
+                       u = w*numpy.nan
+                       u_err = w_err*numpy.nan
+                       p_e0 = p_w0*numpy.nan
+                       p_e1 = p_w1*numpy.nan
+                       #snr1 = 10*numpy.log10(SNR[0])
                     if my_nbeams == 2:
                        zenith = numpy.array(zenith)
                        zenith -= zenithCorrection
                        zenith *= numpy.pi/180
                        if  zenithCorrection != 0 :
                            heiRang1, velRadial1, SNR1 = self.__correctValues(heiRang, numpy.abs(zenith), velRadial, SNR)
                        else :
                            heiRang1 = heiRang
                            velRadial1 = velRadial
                            SNR1 = SNR
                        alp = zenith[0]
                        bet = zenith[1]
                        w_w = velRadial1[0,:]
                        w_e = velRadial1[1,:]
                        w_w_err = velRerr[0,:]
                        w_e_err = velRerr[1,:]
+                       smooth_e = dataOut.clean_num_aver[2,:]
-                       val = (numpy.isfinite(w_w)==False).nonzero()
+                       chisq_e = dataOut.data_error[1,0,:]
-                       val = val[0]
+                       p_e0 = rbufi[2,:]
-                       bad = val
+                       p_e1 = rbufi[3,:]
-                       if len(bad) > 0 :
-                           w_w[bad] = w_wC[bad]
+                       tini=time.localtime(dataOut.utctime)
-                           w_w_err[bad]= numpy.nan
+                       #print(tini[3],tini[4])
+                       #val = (numpy.isfinite(w_w)==False).nonzero()
+                       #val = val[0]
+                       #bad = val
+                       #if len(bad) > 0 :
+                       #    w_w[bad] = w_wC[bad]
+                       #    w_w_err[bad]= numpy.nan
+                       if tini[3] >= 6 and tini[3] < 18 :
+                          w_wtmp = numpy.where(numpy.isfinite(w_wC)==True,w_wC,w_w)
+                          w_w_errtmp = numpy.where(numpy.isfinite(w_wC)==True,numpy.nan,w_w_err)
+                       else:
+                          w_wtmp = numpy.where(numpy.isfinite(w_wC)==True,w_wC,w_w)
+                          w_wtmp = numpy.where(range1 > 200,w_w,w_wtmp)
+                          w_w_errtmp = numpy.where(numpy.isfinite(w_wC)==True,numpy.nan,w_w_err)
+                          w_w_errtmp = numpy.where(range1 > 200,w_w_err,w_w_errtmp)
+                       w_w = w_wtmp
+                       w_w_err = w_w_errtmp
+                       #if my_nbeams == 2:
                        smooth_eC=ebufc[4,:]
                        p_e0C = rbufc[4,:]
                        p_e1C = rbufc[5,:]
                        w_eC = rbufc[6,:]*-1
                        t_eC = rbufc[7,:]
-                       val = (numpy.isfinite(w_e)==False).nonzero()
-                       val = val[0]
+                       val = (numpy.isfinite(p_e0)==False).nonzero()
-                       bad = val
+                       p_e0[val]=0
-                       if len(bad) > 0 :
+                       val = (numpy.isfinite(p_e1)==False).nonzero()
-                           w_e[bad] = w_eC[bad]
+                       p_e1[val]=0
-                           w_e_err[bad]= numpy.nan
+                       val = (numpy.isfinite(p_e0C)==False).nonzero()
+                       p_e0C[val]=0
+                       val = (numpy.isfinite(p_e1C)==False).nonzero()
+                       p_e1C[val]=0
+                       val = (numpy.isfinite(smooth_e)==False).nonzero()
+                       smooth_e[val]=0
+                       val = (numpy.isfinite(smooth_eC)==False).nonzero()
+                       smooth_eC[val]=0
+                       #p_e0 = (p_e0*smooth_e+p_e0C*smooth_eC)/(smooth_e+smooth_eC)
+                       #p_e1 = (p_e1*smooth_e+p_e1C*smooth_eC)/(smooth_e+smooth_eC)
+                       if len(sat_fits) >0 :
+                          p_e0C = p_e0C + sat_fits[2,:]
+                          p_e1C = p_e1C + sat_fits[3,:]
+                       #val = (numpy.isfinite(w_e)==False).nonzero()
+                       #val = val[0]
+                       #bad = val
+                       #if len(bad) > 0 :
+                       #     w_e[bad] = w_eC[bad]
+                       #     w_e_err[bad]= numpy.nan
+                       if tini[3] >= 6 and tini[3] < 18 :
+                          w_etmp = numpy.where(numpy.isfinite(w_eC)==True,w_eC,w_e)
+                          w_e_errtmp = numpy.where(numpy.isfinite(w_eC)==True,numpy.nan,w_e_err)
+                       else:
+                          w_etmp = numpy.where(numpy.isfinite(w_eC)==True,w_eC,w_e)
+                          w_etmp = numpy.where(range1 > 200,w_e,w_etmp)
+                          w_e_errtmp = numpy.where(numpy.isfinite(w_eC)==True,numpy.nan,w_e_err)
+                          w_e_errtmp = numpy.where(range1 > 200,w_e_err,w_e_errtmp)
+                       w_e = w_etmp
+                       w_e_err = w_e_errtmp
                        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))
                        w_err = numpy.sqrt((w_w_err*numpy.sin(bet))**2.+(w_e_err*numpy.sin(alp))**2.)/ numpy.absolute(numpy.cos(alp)*numpy.sin(bet)-numpy.cos(bet)*numpy.sin(alp))
                        u_err = numpy.sqrt((w_w_err*numpy.cos(bet))**2.+(w_e_err*numpy.cos(alp))**2.)/ numpy.absolute(numpy.cos(alp)*numpy.sin(bet)-numpy.cos(bet)*numpy.sin(alp))
                        winds = numpy.vstack((w,u))
+                       #winds = numpy.vstack((w,u,w_err,u_err))
                        dataOut.heightList = heiRang1
-                       snr1 = 10*numpy.log10(SNR1[0])
+                       #snr1 = 10*numpy.log10(SNR1[0])
                     dataOut.data_output = winds
-                    #snr1 = 10*numpy.log10(SNR1[0])# estaba comentado
+                    range1 = dataOut.heightList
-                    dataOut.data_snr1 = numpy.reshape(snr1,(1,snr1.shape[0]))
+                    nhei = len(range1)
-                    #print("data_snr1",dataOut.data_snr1)
+                    #print('alt ',range1*numpy.sin(86.1*numpy.pi/180))
+                    #print(numpy.min([dataOut.eldir7,dataOut.eldir8]))
+                    galt = range1*numpy.sin(numpy.min([dataOut.elw,dataOut.ele])*numpy.pi/180.)
+                    dataOut.params = numpy.vstack((range1,galt,w,w_err,u,u_err,w_w,w_w_err,w_e,w_e_err,numpy.log10(p_w0),numpy.log10(p_w0C),numpy.log10(p_w1),numpy.log10(p_w1C),numpy.log10(p_e0),numpy.log10(p_e0C),numpy.log10(p_e1),numpy.log10(p_e1C),chisq_w,chisq_e))
+                    #snr1 = 10*numpy.log10(SNR1[0])
+                    #print(min(snr1), max(snr1))
+                    snr1 = numpy.vstack((p_w0,p_w1,p_e0,p_e1))
+                    snr1db = 10*numpy.log10(snr1[0])
+                    #dataOut.data_snr1 = numpy.reshape(snr1,(1,snr1.shape[0]))
+                    dataOut.data_snr1 = numpy.reshape(snr1db,(1,snr1db.shape[0]))
                     dataOut.utctimeInit = dataOut.utctime
                     dataOut.outputInterval = dataOut.timeInterval
                     hei_aver0 = 218
                     jrange = 450 #900 para HA drifts
                     deltah = 15.0 #dataOut.spacing(0) 25 HAD
                     h0 = 0.0 #dataOut.first_height(0)
-                    heights = dataOut.heightList
-                    nhei = len(heights)
                     range1 = numpy.arange(nhei) * deltah + h0
                     jhei = (range1 >= hei_aver0).nonzero()
                     if len(jhei[0]) > 0 :
                         h0_index = jhei[0][0] # Initial height for getting averages 218km
                     mynhei = 7
                     nhei_avg = int(jrange/deltah)
                     h_avgs = int(nhei_avg/mynhei)
                     nhei_avg = h_avgs*(mynhei-1)+mynhei
                     navgs = numpy.zeros(mynhei,dtype='float')
                     delta_h = numpy.zeros(mynhei,dtype='float')
                     range_aver = numpy.zeros(mynhei,dtype='float')
                     for ih in range( mynhei-1 ):
                         range_aver[ih] = numpy.sum(range1[h0_index+h_avgs*ih:h0_index+h_avgs*(ih+1)-0])/h_avgs
                         navgs[ih] = h_avgs
                         delta_h[ih] = deltah*h_avgs
                     range_aver[mynhei-1] = numpy.sum(range1[h0_index:h0_index+6*h_avgs-0])/(6*h_avgs)
                     navgs[mynhei-1] = 6*h_avgs
                     delta_h[mynhei-1] = deltah*6*h_avgs
                     wA = w[h0_index:h0_index+nhei_avg-0]
                     wA_err = w_err[h0_index:h0_index+nhei_avg-0]
                     for i in range(5) :
                         vals = wA[i*h_avgs:(i+1)*h_avgs-0]
                         errs = wA_err[i*h_avgs:(i+1)*h_avgs-0]
                         avg = numpy.nansum(vals/errs**2.)/numpy.nansum(1./errs**2.)
                         sigma = numpy.sqrt(1./numpy.nansum(1./errs**2.))
                         wA[6*h_avgs+i] = avg
                         wA_err[6*h_avgs+i] = sigma
                     vals = wA[0:6*h_avgs-0]
                     errs=wA_err[0:6*h_avgs-0]
                     avg = numpy.nansum(vals/errs**2.)/numpy.nansum(1./errs**2)
                     sigma = numpy.sqrt(1./numpy.nansum(1./errs**2.))
                     wA[nhei_avg-1] = avg
                     wA_err[nhei_avg-1] = sigma
                     wA = wA[6*h_avgs:nhei_avg-0]
                     wA_err=wA_err[6*h_avgs:nhei_avg-0]
                     if my_nbeams == 2 :
                         uA = u[h0_index:h0_index+nhei_avg]
                         uA_err=u_err[h0_index:h0_index+nhei_avg]
                         for i in range(5) :
                             vals = uA[i*h_avgs:(i+1)*h_avgs-0]
                             errs=uA_err[i*h_avgs:(i+1)*h_avgs-0]
                             avg = numpy.nansum(vals/errs**2.)/numpy.nansum(1./errs**2.)
                             sigma = numpy.sqrt(1./numpy.nansum(1./errs**2.))
                             uA[6*h_avgs+i] = avg
                             uA_err[6*h_avgs+i]=sigma
                         vals = uA[0:6*h_avgs-0]
                         errs = uA_err[0:6*h_avgs-0]
                         avg = numpy.nansum(vals/errs**2.)/numpy.nansum(1./errs**2.)
                         sigma = numpy.sqrt(1./numpy.nansum(1./errs**2.))
                         uA[nhei_avg-1] = avg
                         uA_err[nhei_avg-1] = sigma
                         uA = uA[6*h_avgs:nhei_avg-0]
                         uA_err = uA_err[6*h_avgs:nhei_avg-0]
                         dataOut.drifts_avg = numpy.vstack((wA,uA))
                     if my_nbeams == 1: dataOut.drifts_avg = wA
+                    #deltahavg= wA*0.0+deltah
+                    dataOut.range = range1
+                    galtavg = range_aver*numpy.sin(numpy.min([dataOut.elw,dataOut.ele])*numpy.pi/180.)
+                    dataOut.params_avg = numpy.vstack((wA,wA_err,uA,uA_err,range_aver,galtavg,delta_h))
+                    #print('comparando dim de avg ',wA.shape,deltahavg.shape,range_aver.shape)
                     tini=time.localtime(dataOut.utctime)
                     datefile= str(tini[0]).zfill(4)+str(tini[1]).zfill(2)+str(tini[2]).zfill(2)
-                    nfile = fileDrifts+'/jro'+datefile+'drifts.txt'
+                    nfile = fileDrifts+'/jro'+datefile+'drifts_sch3.txt'
+                    #nfile = '/home/pcondor/Database/ewdriftsschain2019/jro'+datefile+'drifts_sch3.txt'
+                    #print(len(dataOut.drifts_avg),dataOut.drifts_avg.shape)
                     f1 = open(nfile,'a')
                     datedriftavg=str(tini[0])+' '+str(tini[1])+' '+str(tini[2])+' '+str(tini[3])+' '+str(tini[4])
                     driftavgstr=str(dataOut.drifts_avg)
                     numpy.savetxt(f1,numpy.column_stack([tini[0],tini[1],tini[2],tini[3],tini[4]]),fmt='%4i')
-                    numpy.savetxt(f1,dataOut.drifts_avg,fmt='%10.2f')
+                    numpy.savetxt(f1,numpy.reshape(range_aver,(1,len(range_aver))) ,fmt='%10.2f')
+                    #numpy.savetxt(f1,numpy.reshape(dataOut.drifts_avg,(7,len(dataOut.drifts_avg))) ,fmt='%10.2f')
+                    numpy.savetxt(f1,dataOut.drifts_avg[:,:],fmt='%10.2f')
+                    f1.close()
+                    swfile = fileDrifts+'/jro'+datefile+'drifts_sw.txt'
+                    f1 = open(swfile,'a')
+                    numpy.savetxt(f1,numpy.column_stack([tini[0],tini[1],tini[2],tini[3],tini[4]]),fmt='%4i')
+                    numpy.savetxt(f1,numpy.reshape(heiRang,(1,len(heiRang))),fmt='%10.2f')
+                    numpy.savetxt(f1,dataOut.data_param[:,0,:],fmt='%10.2f')
                     f1.close()
+                    dataOut.heightListtmp = dataOut.heightList
+                    '''
+                    one = {'range':'range','gdlatr': 'lat', 'gdlonr': 'lon', 'inttms': 'paramInterval'} #reader gdlatr-->lat only 1D
+                    two = {
+                       'gdalt': 'heightList',   #<----- nmonics
+                       'VIPN': ('params', 0),
+                       'dvipn': ('params', 1),
+                       'vipe': ('params', 2),
+                       'dvipe': ('params', 3),
+                       'PACWL': ('params', 4),
+                       'pbcwl': ('params', 5),
+                       'pccel': ('params', 6),
+                       'pdcel': ('params', 7)
+                    } #writer
+                    #f=open('/home/roberto/moder_test.txt','r')
+                    #file_contents=f.read()
+                    ind = ['gdalt']
+                    meta = {
+                    'kinst': 10, #instrument code
+                    'kindat': 1910, #type of data
+                    'catalog': {
+                       'principleInvestigator': 'Danny Scipión',
+                       'expPurpose': 'Drifts'#,
+                     #  'sciRemarks': file_contents
+                    },
+                    'header': {
+                        'analyst': 'D. Hysell'
+                    }
+                    }
+                    print('empieza h5 madrigal')
+                    try:
+                       h5mad=MADWriter(dataOut, fileDrifts, one, ind, two, meta, format='hdf5')
+                    except:
+                       print("Error in MADWriter")
+                    print(h5mad)
+                   '''
+                    return dataOut
+            class setHeightDrifts(Operation):
+                def __init__(self):
+                    Operation.__init__(self)
+                def run(self, dataOut):
+                    #print('h inicial ',dataOut.heightList,dataOut.heightListtmp)
+                    dataOut.heightList = dataOut.heightListtmp
+                    #print('regresa H ',dataOut.heightList)
                     return dataOut
+            class setHeightDriftsavg(Operation):
+                def __init__(self):
+                    Operation.__init__(self)
+                def run(self, dataOut):
+                    #print('h inicial ',dataOut.heightList)
+                    dataOut.heightList = dataOut.params_avg[4]
+                    #print('cambia H ',dataOut.params_avg[4],dataOut.heightList)
+                    return dataOut
             #---------------    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)
                         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
                             coh1[p,:,:] = ndimage.median_filter(numpy.abs(ccf), 5) #median filter
                         coh = numpy.nanmax(coh1, axis = 0)
                         #----------------------    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)
                         else:
                             #------------------------    Meteor mask    ---------------------------------
                             #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.median_filter(boolMet2,size=5)
                             boolMet2 = numpy.vstack((boolMet2,numpy.full((1,nHeights), True, dtype=bool)))
                             boolMetFin = boolMet1&boolMet2
                         #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,:,:])
                         velRad = phase*lamb/(4*numpy.pi*tSamp)
                         #Spectral width
                         acf1 = data_acf[:,1,:,:]
                         acf2 = data_acf[:,2,:,:]
                         spcWidth = (lamb/(2*numpy.sqrt(6)*numpy.pi*tSamp))*numpy.sqrt(numpy.log(acf1/acf2))
                         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 = 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
                     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:
                         channelPositions = [(4.5,2), (2,4.5), (2,2), (2,0), (0,2)]   #Estrella
                     meteorOps = SMOperations()
                     pairslist0, distances = meteorOps.getPhasePairs(channelPositions)
                     heiRang = dataOut.heightList
                     #Get Beacon signal - No Beacon signal anymore
                     #****************REMOVING HARDWARE PHASE DIFFERENCES***************
                     # see if the user put in pre defined phase shifts
                     voltsPShift = dataOut.data_pre.copy()
                     #******************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
                     #************ 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)
                     #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.heightList
                     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)
                     #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)
                         dataOut.data_param = arrayParameters
                         if arrayParameters is 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
                     #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.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
                     #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))
                     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]
                     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]
                         #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)
                         noise[startInd:endInd,:] = noise[startInd:endInd,:] + noiseAux
                         noiseAux1 = numpy.mean(arrayBlock)
                         noise1[startInd:endInd,:] = noise1[startInd:endInd,:] + noiseAux1
                     return noise, noise1
                 def __findMeteors(self, power, thresh):
                     nProf = power.shape[0]
                     nHeights = power.shape[1]
                     listMeteors = []
                     for i in range(nHeights):
                         powerAux = power[:,i]
                         threshAux = thresh[:,i]
                         indUPthresh = numpy.where(powerAux > threshAux)[0]
                         indDNthresh = numpy.where(powerAux <= threshAux)[0]
                         j = 0
                         while (j < indUPthresh.size - 2):
                             if (indUPthresh[j + 2] == indUPthresh[j] + 2):
                                 indDNAux = numpy.where(indDNthresh > indUPthresh[j])
                                 indDNthresh = indDNthresh[indDNAux]
                                 if (indDNthresh.size > 0):
                                     indEnd = indDNthresh[0] - 1
                                     indInit = indUPthresh[j]
                                     meteor = powerAux[indInit:indEnd + 1]
                                     indPeak = meteor.argmax() + indInit
                                     FLA = sum(numpy.conj(meteor)*numpy.hstack((meteor[1:],0)))
                                     listMeteors.append(numpy.array([i,indInit,indPeak,indEnd,FLA])) #CHEQUEAR!!!!!
                                     j = numpy.where(indUPthresh == indEnd)[0] + 1
                                 else: j+=1
                             else: j+=1
                     return listMeteors
                 def __removeMultipleDetections(self,listMeteors, rangeLimit, timeLimit):
                     arrayMeteors = numpy.asarray(listMeteors)
                     listMeteors1 = []
                     while arrayMeteors.shape[0] > 0:
                         FLAs = arrayMeteors[:,4]
                         maxFLA = FLAs.argmax()
                         listMeteors1.append(arrayMeteors[maxFLA,:])
                         MeteorInitTime = arrayMeteors[maxFLA,1]
                         MeteorEndTime = arrayMeteors[maxFLA,3]
                         MeteorHeight = arrayMeteors[maxFLA,0]
                         #Check neighborhood
                         maxHeightIndex = MeteorHeight + rangeLimit
                         minHeightIndex = MeteorHeight - rangeLimit
                         minTimeIndex = MeteorInitTime - timeLimit
                         maxTimeIndex = MeteorEndTime + timeLimit
                         #Check Heights
                         indHeight = numpy.logical_and(arrayMeteors[:,0] >= minHeightIndex, arrayMeteors[:,0] <= maxHeightIndex)
                         indTime = numpy.logical_and(arrayMeteors[:,3] >= minTimeIndex, arrayMeteors[:,1] <= maxTimeIndex)
                         indBoth = numpy.where(numpy.logical_and(indTime,indHeight))
                         arrayMeteors = numpy.delete(arrayMeteors, indBoth, axis = 0)
                     return listMeteors1
                 def __meteorReestimation(self, listMeteors, volts, pairslist, thresh, noise, timeInterval,frequency):
                     numHeights = volts.shape[2]
                     nChannel = volts.shape[0]
                     thresholdPhase = thresh[0]
                     thresholdNoise = thresh[1]
                     thresholdDB = float(thresh[2])
                     thresholdDB1 = 10**(thresholdDB/10)
                     pairsarray = numpy.array(pairslist)
                     indSides = pairsarray[:,1]
                     pairslist1 = list(pairslist)
                     pairslist1.append((0,1))
                     pairslist1.append((3,4))
                     listMeteors1 = []
                     listPowerSeries = []
                     listVoltageSeries = []
                     #volts has the war data
                     if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
                     lag = numpy.ceil(timeLag/timeInterval)
                     for i in range(len(listMeteors)):
                         ######################   3.6 - 3.7 PARAMETERS REESTIMATION    #########################
                         meteorAux = numpy.zeros(16)
                         #Loading meteor Data (mHeight, mStart, mPeak, mEnd)
                         mHeight = listMeteors[i][0]
                         mStart = listMeteors[i][1]
                         mPeak = listMeteors[i][2]
                         mEnd = listMeteors[i][3]
                         #get the volt data between the start and end times of the meteor
                         meteorVolts = volts[:,mStart:mEnd+1,mHeight]
                         meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
                         #3.6. Phase Difference estimation
                         phaseDiff, aux = self.__estimatePhaseDifference(meteorVolts, pairslist)
                         #3.7. Phase difference removal & meteor start, peak and end times reestimated
                         #meteorVolts0.- all Channels, all Profiles
                         meteorVolts0 = volts[:,:,mHeight]
                         meteorThresh = noise[:,mHeight]*thresholdNoise
                         meteorNoise = noise[:,mHeight]
                         meteorVolts0[indSides,:] = self.__shiftPhase(meteorVolts0[indSides,:], phaseDiff) #Phase Shifting
                         powerNet0 = numpy.nansum(numpy.abs(meteorVolts0)**2, axis = 0)  #Power
                         #Times reestimation
                         mStart1 = numpy.where(powerNet0[:mPeak] < meteorThresh[:mPeak])[0]
                         if mStart1.size > 0:
                             mStart1 = mStart1[-1] + 1
                         else:
                             mStart1 = mPeak
                         mEnd1 = numpy.where(powerNet0[mPeak:] < meteorThresh[mPeak:])[0][0] + mPeak - 1
                         mEndDecayTime1 = numpy.where(powerNet0[mPeak:] < meteorNoise[mPeak:])[0]
                         if mEndDecayTime1.size == 0:
                             mEndDecayTime1 = powerNet0.size
                         else:
                             mEndDecayTime1 = mEndDecayTime1[0] + mPeak - 1
                         #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 meteorVolts2.shape[1] > 0:
                             #Phase Difference re-estimation
                             phaseDiff1, phaseDiffint = self.__estimatePhaseDifference(meteorVolts2, pairslist1)   #Phase Difference Estimation
                             meteorVolts2 = meteorVolts2.reshape(meteorVolts2.shape[0], meteorVolts2.shape[1])
                             phaseDiff11 = numpy.reshape(phaseDiff1, (phaseDiff1.shape[0],1))
                             meteorVolts2[indSides,:] = self.__shiftPhase(meteorVolts2[indSides,:], phaseDiff11[0:4])     #Phase Shifting
                             #Phase Difference RMS
                             phaseRMS1 = numpy.sqrt(numpy.mean(numpy.square(phaseDiff1)))
                             powerNet1 = numpy.nansum(numpy.abs(meteorVolts1[:,:])**2,0)
                             #Data from Meteor
                             mPeak1 = powerNet1.argmax() + mStart1
                             mPeakPower1 = powerNet1.max()
                             noiseAux = sum(noise[mStart1:mEnd1 + 1,mHeight])
                             mSNR1 = (sum(powerNet1)-noiseAux)/noiseAux
                             Meteor1 = numpy.array([mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1])
                             Meteor1 = numpy.hstack((Meteor1,phaseDiffint))
                             PowerSeries  = powerNet0[mStart1:mEndDecayTime1 + 1]
                             #Vectorize
                             meteorAux[0:7] = [mHeight, mStart1, mPeak1, mEnd1, mPeakPower1, mSNR1, phaseRMS1]
                             meteorAux[7:11] = phaseDiffint[0:4]
                             #Rejection Criterions
                             if phaseRMS1 > thresholdPhase:  #Error Number 17: Phase variation
                                 meteorAux[-1] = 17
                             elif mSNR1 < thresholdDB1:      #Error Number 1: SNR < threshold dB
                                 meteorAux[-1] = 1
                         else:
                             meteorAux[0:4] = [mHeight, mStart, mPeak, mEnd]
                             meteorAux[-1] = 6 #Error Number 6: echo less than 5 samples long; too short for analysis
                             PowerSeries = 0
                         listMeteors1.append(meteorAux)
                         listPowerSeries.append(PowerSeries)
                         listVoltageSeries.append(meteorVolts1)
                     return listMeteors1, listPowerSeries, listVoltageSeries
                 def __estimateDecayTime(self, listMeteors, listPower, timeInterval, frequency):
                     threshError = 10
                     #Depending if it is 30 or 50 MHz
                     if frequency == 30e6:
                         timeLag = 45*10**-3
                     else:
                         timeLag = 15*10**-3
                     lag = numpy.ceil(timeLag/timeInterval)
                     listMeteors1 = []
                     for i in range(len(listMeteors)):
                         meteorPower = listPower[i]
                         meteorAux = listMeteors[i]
                         if meteorAux[-1] == 0:
                             try:
                                 indmax = meteorPower.argmax()
                                 indlag = indmax + lag
                                 y = meteorPower[indlag:]
                                 x = numpy.arange(0, y.size)*timeLag
                                 #first guess
                                 a = y[0]
                                 tau = timeLag
                                 #exponential fit
                                 popt, pcov = optimize.curve_fit(self.__exponential_function, x, y, p0 = [a, tau])
                                 y1 = self.__exponential_function(x, *popt)
                                 #error estimation
                                 error = sum((y - y1)**2)/(numpy.var(y)*(y.size - popt.size))
                                 decayTime = popt[1]
                                 riseTime = indmax*timeInterval
                                 meteorAux[11:13] = [decayTime, error]
                                 #Table items 7, 8 and 11
                                 if (riseTime > 0.3):            #Number 7: Echo rise exceeds 0.3s
                                     meteorAux[-1] = 7
                                 elif (decayTime < 2*riseTime) : #Number 8: Echo decay time less than than twice rise time
                                     meteorAux[-1] = 8
                                 if (error > threshError):       #Number 11: Poor fit to amplitude for estimation of decay time
                                     meteorAux[-1] = 11
                             except:
                                 meteorAux[-1] = 11
                         listMeteors1.append(meteorAux)
                     return listMeteors1
                 #Exponential Function
                 def __exponential_function(self, x, a, tau):
                     y = a*numpy.exp(-x/tau)
                     return y
                 def __getRadialVelocity(self, listMeteors, listVolts, radialStdThresh, pairslist,  timeInterval):
                     pairslist1 = list(pairslist)
                     pairslist1.append((0,1))
                     pairslist1.append((3,4))
                     numPairs = len(pairslist1)
                     #Time Lag
                     timeLag = 45*10**-3
                     c = 3e8
                     lag = numpy.ceil(timeLag/timeInterval)
                     freq = 30e6
                     listMeteors1 = []
                     for i in range(len(listMeteors)):
                         meteorAux = listMeteors[i]
                         if meteorAux[-1] == 0:
                             mStart = listMeteors[i][1]
                             mPeak = listMeteors[i][2]
                             mLag = mPeak - mStart + lag
                             #get the volt data between the start and end times of the meteor
                             meteorVolts = listVolts[i]
                             meteorVolts = meteorVolts.reshape(meteorVolts.shape[0], meteorVolts.shape[1], 1)
                             #Get CCF
                             allCCFs = self.__calculateCCF(meteorVolts, pairslist1, [-2,-1,0,1,2])
                             #Method 2
                             slopes = numpy.zeros(numPairs)
                             time = numpy.array([-2,-1,1,2])*timeInterval
                             angAllCCF = numpy.angle(allCCFs[:,[0,1,3,4],0])
                             #Correct phases
                             derPhaseCCF = angAllCCF[:,1:] - angAllCCF[:,0:-1]
                             indDer = numpy.where(numpy.abs(derPhaseCCF) > numpy.pi)
                             if indDer[0].shape[0] > 0:
                                 for i in range(indDer[0].shape[0]):
                                     signo = -numpy.sign(derPhaseCCF[indDer[0][i],indDer[1][i]])
                                     angAllCCF[indDer[0][i],indDer[1][i]+1:] += signo*2*numpy.pi
                             for j in range(numPairs):
                                 fit = stats.linregress(time, angAllCCF[j,:])
                                 slopes[j] = fit[0]
                             #Remove Outlier
                             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
                     arrayDate = numpy.tile(date, (len(listMeteors)))
                     #Meteor array
                     #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:
                 #             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
                         jgamma = -phip2*d3/d2 - phip3
                         jgamma = numpy.angle(numpy.exp(1j*jgamma))
                         #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[pairsList[0][1]] = alp4
                                 jph[pairsList[0][0]] = alp5
                                 jph[pairsList[1][0]] = alp3
                                 jph[pairsList[1][1]] = alp2
                                 jph_array[:,ix,iy] = jph
                                 meteorsArray1 = meteorOps.getMeteorParams(meteorsArray, azimuth, h, pairsList, d, jph)
                                 error = meteorsArray1[:,-1]
                                 ind1 = numpy.where(error==0)[0]
                                 penalty[ix,iy] = ind1.size
                         i,j = numpy.unravel_index(penalty.argmax(), penalty.shape)
                         phOffset = jph_array[:,i,j]
                         center_xangle = phOffset[pairx[1]]
                         center_yangle = phOffset[pairy[1]]
                     phOffset = numpy.angle(numpy.exp(1j*jph_array[:,i,j]))
                     phOffset = phOffset*180/numpy.pi
                     return phOffset
                 def run(self, dataOut, hmin, hmax, channelPositions=None, nHours = 1):
                     dataOut.flagNoData = True
                     self.__dataReady = False
                     dataOut.outputInterval = nHours*3600
                     if self.__isConfig == False:
                         #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:
                         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)
                         if channelPositions is None:
                             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))
                         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)
                         #Calculate Phases
                         phasesOff = self.__getPhases(azimuth, h, pairs, distances, gammas, meteorsArray)
                         phasesOff = phasesOff.reshape((1,phasesOff.size))
                         dataOut.data_output = -phasesOff
                         dataOut.flagNoData = False
                         self.__buffer = None
                     return
             class SMOperations():
                 def __init__(self):
                     return
                 def getMeteorParams(self, arrayParameters0, azimuth, h, pairsList, distances, jph):
                     arrayParameters = arrayParameters0.copy()
                     hmin = h[0]
                     hmax = h[1]
                     #Calculate AOA (Error N 3, 4)
                     #JONES ET AL. 1998
                     AOAthresh = numpy.pi/8
                     error = arrayParameters[:,-1]
                     phases = -arrayParameters[:,8:12] + jph
                     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    ------------------------------------
                     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))
                         #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(list(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])
                     pairslist = [(chanCX, chan1X),(chanCX, chan2X),(chanCY,chan1Y),(chanCY, chan2Y)]
                     return pairslist, distances
             class IGRFModel(Operation):
                 """Operation to calculate Geomagnetic parameters.
                 Parameters:
                 -----------
                 None
                 Example
                 --------
                 op = proc_unit.addOperation(name='IGRFModel', optype='other')
                 """
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.aux=1
                 def run(self,dataOut):
                     try:
                         from schainpy.model.proc import mkfact_short_2020
                     except:
                         log.warning('You should install "mkfact_short_2020" module to process IGRF Model')
                     if self.aux==1:
                         #dataOut.TimeBlockSeconds_First_Time=time.mktime(time.strptime(dataOut.TimeBlockDate))
                         #### we do not use dataOut.datatime.ctime() because it's the time of the second (next) block
                         dataOut.TimeBlockSeconds_First_Time=dataOut.TimeBlockSeconds
                         dataOut.bd_time=time.gmtime(dataOut.TimeBlockSeconds_First_Time)
                         dataOut.year=dataOut.bd_time.tm_year+(dataOut.bd_time.tm_yday-1)/364.0
                         dataOut.ut=dataOut.bd_time.tm_hour+dataOut.bd_time.tm_min/60.0+dataOut.bd_time.tm_sec/3600.0
                         self.aux=0
                         dataOut.h=numpy.arange(0.0,15.0*dataOut.MAXNRANGENDT,15.0,dtype='float32')
                         dataOut.bfm=numpy.zeros(dataOut.MAXNRANGENDT,dtype='float32')
                         dataOut.bfm=numpy.array(dataOut.bfm,order='F')
                         dataOut.thb=numpy.zeros(dataOut.MAXNRANGENDT,dtype='float32')
                         dataOut.thb=numpy.array(dataOut.thb,order='F')
                         dataOut.bki=numpy.zeros(dataOut.MAXNRANGENDT,dtype='float32')
                         dataOut.bki=numpy.array(dataOut.bki,order='F')
                         mkfact_short_2020.mkfact(dataOut.year,dataOut.h,dataOut.bfm,dataOut.thb,dataOut.bki,dataOut.MAXNRANGENDT)
                     return dataOut
             class MergeProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                 def run(self, attr_data, attr_data_2 = None, attr_data_3 = None, attr_data_4 = None, attr_data_5 = None, mode=0):
                     self.dataOut = getattr(self, self.inputs[0])
                     data_inputs = [getattr(self, attr) for attr in self.inputs]
                     #print(self.inputs)
                     #print(numpy.shape([getattr(data, attr_data) for data in data_inputs][1]))
                     #exit(1)
                     if mode==0:
                         data = numpy.concatenate([getattr(data, attr_data) for data in data_inputs])
                         setattr(self.dataOut, attr_data, data)
                     if mode==1: #Hybrid
                         #data = numpy.concatenate([getattr(data, attr_data) for data in data_inputs],axis=1)
                         #setattr(self.dataOut, attr_data, data)
                         setattr(self.dataOut, 'dataLag_spc', [getattr(data, attr_data) for data in data_inputs][0])
                         setattr(self.dataOut, 'dataLag_spc_LP', [getattr(data, attr_data) for data in data_inputs][1])
                         setattr(self.dataOut, 'dataLag_cspc', [getattr(data, attr_data_2) for data in data_inputs][0])
                         setattr(self.dataOut, 'dataLag_cspc_LP', [getattr(data, attr_data_2) for data in data_inputs][1])
                         #setattr(self.dataOut, 'nIncohInt', [getattr(data, attr_data_3) for data in data_inputs][0])
                         #setattr(self.dataOut, 'nIncohInt_LP', [getattr(data, attr_data_3) for data in data_inputs][1])
                         '''
                         print(self.dataOut.dataLag_spc_LP.shape)
                         print(self.dataOut.dataLag_cspc_LP.shape)
                         exit(1)
                         '''
                         #self.dataOut.dataLag_spc_LP = numpy.transpose(self.dataOut.dataLag_spc_LP[0],(2,0,1))
                         #self.dataOut.dataLag_cspc_LP = numpy.transpose(self.dataOut.dataLag_cspc_LP,(3,1,2,0))
                         '''
                         print("Merge")
                         print(numpy.shape(self.dataOut.dataLag_spc))
                         print(numpy.shape(self.dataOut.dataLag_spc_LP))
                         print(numpy.shape(self.dataOut.dataLag_cspc))
                         print(numpy.shape(self.dataOut.dataLag_cspc_LP))
                         exit(1)
                         '''
                         #print(numpy.sum(self.dataOut.dataLag_spc_LP[2,:,164])/128)
                         #print(numpy.sum(self.dataOut.dataLag_cspc_LP[0,:,30,1])/128)
                         #exit(1)
                         #print(self.dataOut.NDP)
                         #print(self.dataOut.nNoiseProfiles)
                         #self.dataOut.nIncohInt_LP = 128
                         self.dataOut.nProfiles_LP = 128#self.dataOut.nIncohInt_LP
                         self.dataOut.nIncohInt_LP = self.dataOut.nIncohInt
                         self.dataOut.NLAG = 16
                         self.dataOut.NRANGE = 200
                         self.dataOut.NSCAN = 128
                         #print(numpy.shape(self.dataOut.data_spc))
                         #exit(1)
                     if mode==2: #HAE 2022
                         data = numpy.sum([getattr(data, attr_data) for data in data_inputs],axis=0)
                         setattr(self.dataOut, attr_data, data)
                         self.dataOut.nIncohInt *= 2
                         #meta = self.dataOut.getFreqRange(1)/1000.
                         self.dataOut.freqRange = self.dataOut.getFreqRange(1)/1000.
                         #exit(1)
                     if mode==4: #Hybrid LP-SSheightProfiles
                         #data = numpy.concatenate([getattr(data, attr_data) for data in data_inputs],axis=1)
                         #setattr(self.dataOut, attr_data, data)
                         setattr(self.dataOut, 'dataLag_spc', getattr(data_inputs[0], attr_data)) #DP
                         setattr(self.dataOut, 'dataLag_cspc', getattr(data_inputs[0], attr_data_2)) #DP
                         setattr(self.dataOut, 'dataLag_spc_LP', getattr(data_inputs[1], attr_data_3)) #LP
                         #setattr(self.dataOut, 'dataLag_cspc_LP', getattr(data_inputs[1], attr_data_4)) #LP
                         #setattr(self.dataOut, 'data_acf', getattr(data_inputs[1], attr_data_5)) #LP
                         setattr(self.dataOut, 'data_acf', getattr(data_inputs[1], attr_data_5)) #LP
                         #print("Merge data_acf: ",self.dataOut.data_acf.shape)
                         #exit(1)
                         #print(self.dataOut.data_spc_LP.shape)
                         #print("Exit")
                         #exit(1)
                         #setattr(self.dataOut, 'dataLag_cspc', [getattr(data, attr_data_2) for data in data_inputs][0])
                         #setattr(self.dataOut, 'dataLag_cspc_LP', [getattr(data, attr_data_2) for data in data_inputs][1])
                         #setattr(self.dataOut, 'nIncohInt', [getattr(data, attr_data_3) for data in data_inputs][0])
                         #setattr(self.dataOut, 'nIncohInt_LP', [getattr(data, attr_data_3) for data in data_inputs][1])
                         '''
                         print(self.dataOut.dataLag_spc_LP.shape)
                         print(self.dataOut.dataLag_cspc_LP.shape)
                         exit(1)
                         '''
                         '''
                         print(self.dataOut.dataLag_spc_LP[0,:,100])
                         print(self.dataOut.dataLag_spc_LP[1,:,100])
                         exit(1)
                         '''
                         #self.dataOut.dataLag_spc_LP = numpy.transpose(self.dataOut.dataLag_spc_LP[0],(2,0,1))
                         #self.dataOut.dataLag_cspc_LP = numpy.transpose(self.dataOut.dataLag_cspc_LP,(3,1,2,0))
                         '''
                         print("Merge")
                         print(numpy.shape(self.dataOut.dataLag_spc))
                         print(numpy.shape(self.dataOut.dataLag_spc_LP))
                         print(numpy.shape(self.dataOut.dataLag_cspc))
                         print(numpy.shape(self.dataOut.dataLag_cspc_LP))
                         exit(1)
                         '''
                         #print(numpy.sum(self.dataOut.dataLag_spc_LP[2,:,164])/128)
                         #print(numpy.sum(self.dataOut.dataLag_cspc_LP[0,:,30,1])/128)
                         #exit(1)
                         #print(self.dataOut.NDP)
                         #print(self.dataOut.nNoiseProfiles)
                         #self.dataOut.nIncohInt_LP = 128
                         #self.dataOut.nProfiles_LP = 128#self.dataOut.nIncohInt_LP
                         self.dataOut.nProfiles_LP = 16#28#self.dataOut.nIncohInt_LP
                         self.dataOut.nProfiles_LP = self.dataOut.data_acf.shape[1]#28#self.dataOut.nIncohInt_LP
                         self.dataOut.NSCAN = 128
                         self.dataOut.nIncohInt_LP = self.dataOut.nIncohInt*self.dataOut.NSCAN
                         #print("sahpi",self.dataOut.nIncohInt_LP)
                         #exit(1)
                         self.dataOut.NLAG = 16
                         self.dataOut.NRANGE = self.dataOut.data_acf.shape[-1]
                         #print(numpy.shape(self.dataOut.data_spc))
                         #exit(1)
                     if mode==5:
                         data = numpy.concatenate([getattr(data, attr_data) for data in data_inputs])
                         setattr(self.dataOut, attr_data, data)
                         data = numpy.concatenate([getattr(data, attr_data_2) for data in data_inputs])
                         setattr(self.dataOut, attr_data_2, data)
                         #data = numpy.concatenate([getattr(data, attr_data_3) for data in data_inputs])
                         #setattr(self.dataOut, attr_data_3, data)
                         #print(self.dataOut.moments.shape,self.dataOut.data_snr.shape,self.dataOut.heightList.shape)
             class addTxPower(Operation):
                 '''
                 Transmited power level integrated in the dataOut ->AMISR
                 resolution 1 min
                 The power files have the pattern power_YYYYMMDD.csv
                 '''
                 __slots__ =('isConfig','dataDatetimes','txPowers')
                 def __init__(self):
                     Operation.__init__(self)
                     self.isConfig = False
                     self.dataDatetimes = []
                     self.txPowers = []
                 def setup(self, powerFile, dutyCycle):
                     if not os.path.isfile(powerFile):
                         raise schainpy.admin.SchainError('There is no file named :{}'.format(powerFile))
                         return
                     with open(powerFile, newline='') as pfile:
                         reader = csv.reader(pfile, delimiter=',', quotechar='|')
                         next(reader)
                         for row in reader:
                             #'2022-10-25 00:00:00'
                             self.dataDatetimes.append(datetime.datetime.strptime(row[0], "%Y-%m-%d %H:%M:%S"))
                             self.txPowers.append(float(row[1])/dutyCycle)
                     self.isConfig = True
                 def run(self, dataOut, path, DS=0.05):
                     #dataOut.flagNoData = True
                     if not(self.isConfig):
                         self.setup(path, DS)
                     dataDate = datetime.datetime.utcfromtimestamp(dataOut.utctime).replace(second=0, microsecond=0)#no seconds
                     try:
                         indx = self.dataDatetimes.index(dataDate)
                         dataOut.txPower = self.txPowers[indx]
                     except:
                         log.warning("No power available for the datetime {}, setting power to 0 w", self.name)
                         dataOut.txPower = 0
                     return dataOut

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