schain Commit - r1294:575339b32691 · Jicamarca Repository

Ultimo avance simulador y pruebas de procesaiento Weather Radar

avaldez -

r1294:575339b32691 v3.0-devel-wrc

parent child

Context file:

r1294:575339b32691

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

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
             import json
             from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader
             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 lnoise
             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
             class JROData(GenericData):
                 #    m_BasicHeader = BasicHeader()
                 #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None  # dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #     nBaud = None
             #     code = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 # Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 error = None
                 data = None
                 nmodes = None
                 def __str__(self):
                     return '{} - {}'.format(self.type, self.getDatatime())
                 def getNoise(self):
                     raise NotImplementedError
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDeltaH(self):
                     delta = self.heightList[1] - self.heightList[0]
                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 def getDatatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval + 1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
+                    #print("frequency",self.frequency)
                     _lambda = self.C / self.frequency
                     vmax = self.getFmax() * _lambda / 2
                     return vmax
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(
                     getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 # data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 def getNoisebyHildebrand(self, channel=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel, :].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type=1, channel=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel=None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10 * numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 # data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 # data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 # data dc es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 # data power
                 data_pwr = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None  # Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None  # se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         # 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
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return list(range(self.nPairs))
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
                         return self.nmodes*timeInterval
                     else:
                         return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10 * numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" % (
                                     pair))
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real) * 180 / numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(
                     getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue,
                                       "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue,
                                         "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 # Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(
                     getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 ippSeconds = property(get_ippSeconds, '')
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 #--------------------------------------------------
                 mode = None
                 split = False
                 data_cf = None
                 lags = None
                 lagRange = None
                 pairsList = None
                 normFactor = None
                 #--------------------------------------------------
             #     calculateVelocity = None
                 nLags = None
                 nPairs = None
                 nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode=2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:, :, indR, :]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
                         ind_vel[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
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
                     return timeInterval
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         # Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 def getNormFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs == ch0, :, :], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs == ch1, :, :], axis=1)
                         normFactor[p, :] = numpy.sqrt(ch0_max * ch1_max)
                     return normFactor
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None  # Information about the experiment
                 # Information from previous data
                 inputUnit = None  # Type of data to be processed
                 operation = None  # Type of operation to parametrize
                 # normFactor = None       #Normalization Factor
                 groupList = None  # List of Pairs, Groups, etc
                 # Parameters
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None  # Abscissa, can be velocities, lags or time
             #    noise = None            #Noise Potency
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 # Fitting
                 data_error = None  # Error of the estimation
                 constants = None
                 library = None
                 # Output signal
                 outputInterval = None  # Time interval to calculate output signal in seconds
                 data_output = None  # Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone * 60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getTimeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 timeInterval = property(getTimeInterval)
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
             class PlotterData(object):
                 '''
                 Object to hold data to be plotted
                 '''
                 MAXNUMX = 100
                 MAXNUMY = 100
                 def __init__(self, code, throttle_value, exp_code, buffering=True, snr=False):
                     self.key = code
                     self.throttle = throttle_value
                     self.exp_code = exp_code
                     self.buffering = buffering
                     self.ready = False
                     self.localtime = False
                     self.data = {}
                     self.meta = {}
                     self.__times = []
                     self.__heights = []
                     if 'snr' in code:
                         self.plottypes = ['snr']
                     elif code == 'spc':
                         self.plottypes = ['spc', 'noise', 'rti']
                     elif code == 'rti':
                         self.plottypes = ['noise', 'rti']
                     else:
                         self.plottypes = [code]
                     if 'snr' not in self.plottypes and snr:
                         self.plottypes.append('snr')
                     for plot in self.plottypes:
                         self.data[plot] = {}
                 def __str__(self):
                     dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
                     return 'Data[{}][{}]'.format(';'.join(dum), len(self.__times))
                 def __len__(self):
                     return len(self.__times)
                 def __getitem__(self, key):
                     if key not in self.data:
                         raise KeyError(log.error('Missing key: {}'.format(key)))
                     if 'spc' in key or not self.buffering:
                         ret = self.data[key]
                     elif 'scope' in key:
                         ret = numpy.array(self.data[key][float(self.tm)])
                     else:
                         ret = numpy.array([self.data[key][x] for x in self.times])
                         if ret.ndim > 1:
                             ret = numpy.swapaxes(ret, 0, 1)
                     return ret
                 def __contains__(self, key):
                     return key in self.data
                 def setup(self):
                     '''
                     Configure object
                     '''
                     self.type = ''
                     self.ready = False
                     self.data = {}
                     self.__times = []
                     self.__heights = []
                     self.__all_heights = set()
                     for plot in self.plottypes:
                         if 'snr' in plot:
                             plot = 'snr'
                         elif 'spc_moments' == plot:
                             plot = 'moments'
                         self.data[plot] = {}
                     if 'spc' in self.data or 'rti' in self.data or 'cspc' in self.data or 'moments' in self.data:
                         self.data['noise'] = {}
                         self.data['rti'] = {}
                         if 'noise' not in self.plottypes:
                             self.plottypes.append('noise')
                         if 'rti' not in self.plottypes:
                             self.plottypes.append('rti')
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     if len(self.data[key]):
                         if 'spc' in key or not self.buffering:
                             return self.data[key].shape
                         return self.data[key][self.__times[0]].shape
                     return (0,)
                 def update(self, dataOut, tm):
                     '''
                     Update data object with new dataOut
                     '''
                     if tm in self.__times:
                         return
                     self.profileIndex = dataOut.profileIndex
                     self.tm = tm
                     self.type = dataOut.type
                     self.parameters = getattr(dataOut, 'parameters', [])
                     if hasattr(dataOut, 'meta'):
                         self.meta.update(dataOut.meta)
                     self.pairs = dataOut.pairsList
                     self.interval = dataOut.getTimeInterval()
                     self.localtime = dataOut.useLocalTime
                     if 'spc' in self.plottypes or 'cspc' in self.plottypes or 'spc_moments' in self.plottypes:
                         self.xrange = (dataOut.getFreqRange(1)/1000.,
                                        dataOut.getAcfRange(1), dataOut.getVelRange(1))
                         self.factor = dataOut.normFactor
                     self.__heights.append(dataOut.heightList)
                     self.__all_heights.update(dataOut.heightList)
                     self.__times.append(tm)
                     for plot in self.plottypes:
                         if plot in ('spc', 'spc_moments'):
                             z = dataOut.data_spc/dataOut.normFactor
                             buffer = 10*numpy.log10(z)
                         if plot == 'cspc':
                             z = dataOut.data_spc/dataOut.normFactor
                             buffer = (dataOut.data_spc, dataOut.data_cspc)
                         if plot == 'noise':
                             buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                         if plot == 'rti':
                             buffer = dataOut.getPower()
                         if plot == 'snr_db':
                             buffer = dataOut.data_SNR
                         if plot == 'snr':
                             buffer = 10*numpy.log10(dataOut.data_SNR)
                         if plot == 'dop':
                             buffer = dataOut.data_DOP
                         if plot == 'pow':
                             buffer = 10*numpy.log10(dataOut.data_POW)
                         if plot == 'width':
                             buffer = dataOut.data_WIDTH
                         if plot == 'coh':
                             buffer = dataOut.getCoherence()
                         if plot == 'phase':
                             buffer = dataOut.getCoherence(phase=True)
                         if plot == 'output':
                             buffer = dataOut.data_output
                         if plot == 'param':
                             buffer = dataOut.data_param
                         if plot == 'scope':
                             buffer = dataOut.data
                             self.flagDataAsBlock = dataOut.flagDataAsBlock
                             self.nProfiles = dataOut.nProfiles
                         if plot == 'spc':
                             self.data['spc'] = buffer
                         elif plot == 'cspc':
                             self.data['spc'] = buffer[0]
                             self.data['cspc'] = buffer[1]
                         elif plot == 'spc_moments':
                             self.data['spc'] = buffer
                             self.data['moments'][tm] = dataOut.moments
                         else:
                             if self.buffering:
                                 self.data[plot][tm] = buffer
                             else:
                                 self.data[plot] = buffer
                     if dataOut.channelList is None:
                         self.channels = range(buffer.shape[0])
                     else:
                         self.channels = dataOut.channelList
                 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.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, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
                     tm = self.times[-1]
                     dy = int(self.heights.size/self.MAXNUMY) + 1
                     if self.key in ('spc', 'cspc') or not self.buffering:
                         dx = int(self.data[self.key].shape[1]/self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[self.key][::, ::dx, ::dy].tolist())
                     else:
                         data = self.roundFloats(self.data[self.key][tm].tolist())
                         if self.key is 'noise':
                             data = [[x] for x in data]
                     meta = {}
                     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.heights[::dy].tolist())
                     if 'spc' in self.data or 'cspc' in self.data:
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
                     else:
                         meta['xrange'] = []
                     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 = numpy.array(self.__times)
                     ret.sort()
                     return 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_voltage.py +294 -8

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator  #YONG
             from schainpy.utils import log
             from .figure import Figure
             @MPDecorator
             class Scope_(Figure):
                 isConfig = None
                 def __init__(self):#, **kwargs):          #YONG
                     Figure.__init__(self)#, **kwargs)
                     self.isConfig = False
                     self.WIDTH = 300
                     self.HEIGHT = 200
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     self.createFigure(id=id,
                                       wintitle=wintitle,
                                       show=show)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity - IQ"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
                         if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         axes.pline(x, yreal[i,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                         axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
                 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(yreal)
                         if ymax == None: ymax = numpy.nanmax(yreal)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                 def plot_weatherpower(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
-                    y = y[channelIndexList,:]
-                    yreal = y
+                    #x = x[channelIndexList,:]
+                    y = y[channelIndexList,:].real
+                    y = 10*numpy.log10(y)
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
-                        if ymin == None: ymin = numpy.nanmin(yreal)
+                        if ymin == None: ymin = numpy.nanmin(y)
-                        if ymax == None: ymax = numpy.nanmax(yreal)
+                        if ymax == None: ymax = numpy.nanmax(y)
+                        #print (xmin,xmax)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
-                        ychannel = yreal[i,:]
+                        #print(numpy.nanmax(x))
+                        ychannel    = y[i,:]
+                        #ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
+                def plot_weathervelocity(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
+                    #print(channelIndexList)
+                    x = x[channelIndexList,:]
+                    title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
+                    xlabel = "Velocity (m/s)"
+                    ylabel = "Range (Km)"
+                    if not self.isConfig:
+                        nplots = len(channelIndexList)
+                        self.setup(id=id,
+                                   nplots=nplots,
+                                   wintitle='',
+                                   show=show)
+                        if xmin == None: xmin = numpy.nanmin(x)
+                        if xmax == None: xmax = numpy.nanmax(x)
+                        if ymin == None: ymin = numpy.nanmin(y)
+                        if ymax == None: ymax = numpy.nanmax(y)
+                        print (xmin,xmax)
+                        self.isConfig = True
+                    self.setWinTitle(title)
+                    for i in range(len(self.axesList)):
+                        title = "Channel %d" %(i)
+                        axes = self.axesList[i]
+                        #print(numpy.nanmax(x))
+                        xchannel    = x[i,:]
+                        #ychannel = yreal[i,:]
+                        axes.pline(xchannel, y,
+                                    xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
+                                    xlabel=xlabel, ylabel=ylabel, title=title)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, show=True, wr_period=1,
                         ftp=False, server=None, folder=None, username=None, password=None, type='power', **kwargs):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     #print("***************** PLOTEO **************************")
                     #print(dataOut.nProfiles)
                     #print(dataOut.heightList.shape)
                     #print(dataOut.data.shape)
                     if dataOut.flagDataAsBlock:
                         for i in range(dataOut.nProfiles):
                             wintitle1 = wintitle + " [Profile = %d] " %i
                             if type == "power":
                                 self.plot_power(dataOut.heightList,
                                                 dataOut.data[:,i,:],
                                                 id,
                                                 channelIndexList,
                                                 thisDatetime,
                                                 wintitle1,
                                                 show,
                                                 xmin,
                                                 xmax,
                                                 ymin,
                                                 ymax)
                             if type == "weatherpower":
                                 self.plot_weatherpower(dataOut.heightList,
                                                 dataOut.data[:,i,:],
                                                 id,
                                                 channelIndexList,
                                                 thisDatetime,
-                                                wintitle1,
+                                                wintitle,
                                                 show,
                                                 xmin,
                                                 xmax,
                                                 ymin,
                                                 ymax)
                             if type == "weathervelocity":
-                                self.plot_weatherpower(dataOut.heightList,
+                                self.plot_weathervelocity(dataOut.data_velocity[:,i,:],
-                                                dataOut.data_velocity[:,i,:],
+                                                dataOut.heightList,
                                                 id,
                                                 channelIndexList,
                                                 thisDatetime,
                                                 wintitle1,
                                                 show,
                                                 xmin,
                                                 xmax,
                                                 ymin,
                                                 ymax)
                             if type == "iq":
                                 self.plot_iq(dataOut.heightList,
                                              dataOut.data[:,i,:],
                                              id,
                                              channelIndexList,
                                              thisDatetime,
                                              wintitle1,
                                              show,
                                              xmin,
                                              xmax,
                                              ymin,
                                              ymax)
                             self.draw()
                             str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                             figfile = self.getFilename(name = str_datetime) + "_" + str(i)
                             self.save(figpath=figpath,
                                       figfile=figfile,
                                       save=save,
                                       ftp=ftp,
                                       wr_period=wr_period,
                                       thisDatetime=thisDatetime)
                     else:
                         wintitle += " [Profile = %d] " %dataOut.profileIndex
                         if type == "power":
                             self.plot_power(dataOut.heightList,
                                             dataOut.data,
                                             id,
                                             channelIndexList,
                                             thisDatetime,
                                             wintitle,
                                             show,
                                             xmin,
                                             xmax,
                                             ymin,
                                             ymax)
                         if type == "iq":
                             self.plot_iq(dataOut.heightList,
                                          dataOut.data,
                                          id,
                                          channelIndexList,
                                          thisDatetime,
                                          wintitle,
                                          show,
                                          xmin,
                                          xmax,
                                          ymin,
                                          ymax)
+                        if type== "weatherpower":
+                            self.plot_weatherpower(dataOut.heightList,
+                                            dataOut.data,
+                                            id,
+                                            channelIndexList,
+                                            thisDatetime,
+                                            wintitle,
+                                            show,
+                                            xmin,
+                                            xmax,
+                                            ymin,
+                                            ymax)
+                        if type== "weathervelocity":
+                            self.plot_weathervelocity(dataOut.data_velocity,
+                                            dataOut.heightList,
+                                            id,
+                                            channelIndexList,
+                                            thisDatetime,
+                                            wintitle,
+                                            show,
+                                            xmin,
+                                            xmax,
+                                            ymin,
+                                            ymax)
                     self.draw()
                     str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") + "_" + str(dataOut.profileIndex)
                     figfile = self.getFilename(name = str_datetime)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
+            @MPDecorator
+            class TimePlot_(Figure):
+                __isConfig = None
+                __nsubplots = None
+                WIDTHPROF = None
+                HEIGHTPROF = None
+                PREFIX = 'time'
+                def __init__(self):
+                    Figure.__init__(self)
+                    self.timerange = None
+                    self.isConfig = False
+                    self.__nsubplots = 1
+                    self.WIDTH = 800
+                    self.HEIGHT = 250
+                    self.WIDTHPROF = 120
+                    self.HEIGHTPROF = 0
+                    self.counter_imagwr = 0
+                    self.PLOT_CODE = RTIVOLT_CODE
+                    self.FTP_WEI = None
+                    self.EXP_CODE = None
+                    self.SUB_EXP_CODE = None
+                    self.PLOT_POS = None
+                    self.tmin = None
+                    self.tmax = None
+                    self.xmin = None
+                    self.xmax = None
+                    self.figfile = None
+                def getSubplots(self):
+                    ncol = 1
+                    nrow = self.nplots
+                    return nrow, ncol
+                def setup(self, id, nplots, wintitle, showprofile=True, show=True):
+                    self.__showprofile = showprofile
+                    self.nplots = nplots
+                    ncolspan = 1
+                    colspan = 1
+                    if showprofile:
+                        ncolspan = 7
+                        colspan = 6
+                        self.__nsubplots = 2
+                    self.createFigure(id = id,
+                                      wintitle = wintitle,
+                                      widthplot = self.WIDTH + self.WIDTHPROF,
+                                      heightplot = self.HEIGHT + self.HEIGHTPROF,
+                                      show=show)
+                    nrow, ncol = self.getSubplots()
+                    counter = 0
+                    for y in range(nrow):
+                        for x in range(ncol):
+                            if counter >= self.nplots:
+                                break
+                            self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
+                            if showprofile:
+                                self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
+                            counter += 1
+                def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
+                        xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,type="intensity",
+                        timerange=None, colormap='jet',
+                        save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
+                        server=None, folder=None, username=None, password=None,
+                        ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
+                    """
+                    Input:
+                        dataOut         :
+                        id        :
+                        wintitle        :
+                        channelList     :
+                        showProfile     :
+                        xmin            :    None,
+                        xmax            :    None,
+                        ymin            :    None,
+                        ymax            :    None,
+                        zmin            :    None,
+                        zmax            :    None
+                    """
+                    print("estoy aqui :D")
+                    if dataOut.flagNoData:
+                        return dataOut
+                    #colormap = kwargs.get('colormap', 'jet')
+                    if HEIGHT is not None:
+                        self.HEIGHT  = HEIGHT
+                    if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
+                        return
+                    if channelList == None:
+                        channelIndexList = dataOut.channelIndexList
+                    else:
+                        channelIndexList = []
+                        for channel in channelList:
+                            if channel not in dataOut.channelList:
+                                raise ValueError("Channel %d is not in dataOut.channelList")
+                            channelIndexList.append(dataOut.channelList.index(channel))
+                    if normFactor is None:
+                        factor = dataOut.normFactor
+                    else:
+                        factor = normFactor
+                    #factor = dataOut.normFactor
+                    x = dataOut.getTimeRange()
+                    y = dataOut.getHeiRange()
+                    if type=="intensity":
+                        z = dataOut.data_intensity/factor
+                        z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
+                        avgdB = numpy.average(z, axis=1)
+                        avgdB = 10.*numpy.log10(avg)
+                    else:
+                        z= dataOut.data_velocity
+                        avgdB = numpy.average(z, axis=1)
+                    # avgdB = dataOut.getPower()
+                    thisDatetime = dataOut.datatime
+                    #thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
+                    title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
+                    xlabel = ""
+                    ylabel = "Range (Km)"
+                    update_figfile = False
+                    if self.xmax is not None and dataOut.ltctime >= self.xmax: #yong
+                        self.counter_imagwr = wr_period
+                        self.isConfig = False
+                        update_figfile = True
+                    if not self.isConfig:
+                        nplots = len(channelIndexList)
+                        self.setup(id=id,
+                                   nplots=nplots,
+                                   wintitle=wintitle,
+                                   showprofile=showprofile,
+                                   show=show)
+                        if timerange != None:
+                            self.timerange = timerange
+                        self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
+                        noise = dataOut.noise/factor
+                        noisedB = 10*numpy.log10(noise)
+                        if ymin == None: ymin = numpy.nanmin(y)
+                        if ymax == None: ymax = numpy.nanmax(y)
+                        if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
+                        if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
+                        self.FTP_WEI = ftp_wei
+                        self.EXP_CODE = exp_code
+                        self.SUB_EXP_CODE = sub_exp_code
+                        self.PLOT_POS = plot_pos
+                        self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
+                        self.isConfig = True
+                        self.figfile = figfile
+                        update_figfile = True
+                    self.setWinTitle(title)
+                    for i in range(self.nplots):
+                        index = channelIndexList[i]
+                        title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
+                        if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
+                            title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
+                        axes = self.axesList[i*self.__nsubplots]
+                        zdB = avgdB[index].reshape((1,-1))
+                        axes.pcolorbuffer(x, y, zdB,
+                                    xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
+                                    xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
+                                    ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
+                        if self.__showprofile:
+                            axes = self.axesList[i*self.__nsubplots +1]
+                            axes.pline(avgdB[index], y,
+                                    xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
+                                    xlabel='dB', ylabel='', title='',
+                                    ytick_visible=False,
+                                    grid='x')
+                    self.draw()
+                    self.save(figpath=figpath,
+                              figfile=figfile,
+                              save=save,
+                              ftp=ftp,
+                              wr_period=wr_period,
+                              thisDatetime=thisDatetime,
+                              update_figfile=update_figfile)
+                    return dataOut

schainpy/model/graphics/plotting_codes.py +1 0

             '''
             @author: roj-idl71
             '''
             #USED IN jroplot_spectra.py
             RTI_CODE = 0            #Range time intensity (RTI).
             SPEC_CODE = 1           #Spectra (and Cross-spectra) information.
             CROSS_CODE = 2          #Cross-Correlation information.
             COH_CODE = 3            #Coherence map.
             BASE_CODE = 4           #Base lines graphic.
             ROW_CODE = 5            #Row Spectra.
             TOTAL_CODE = 6          #Total Power.
             DRIFT_CODE = 7          #Drifts graphics.
             HEIGHT_CODE = 8         #Height profile.
             PHASE_CODE = 9          #Signal Phase.
             POWER_CODE = 16
             NOISE_CODE = 17
             BEACON_CODE = 18
             #USED IN jroplot_parameters.py
             WIND_CODE = 22
             MSKYMAP_CODE = 23
             MPHASE_CODE = 24
             MOMENTS_CODE = 25
             PARMS_CODE   = 26
             SPECFIT_CODE = 27
             EWDRIFT_CODE = 28
             WPO_CODE     = 29         #Weather Intensity - Power
+            RTIVOLT_CODE = 30

schainpy/model/io/jroIO_simulator.py +25 -9

             import numpy,math,random,time
             import zmq
             import tempfile
             from io import StringIO
             ########## 1  Heredamos JRODatareader
             from schainpy.model.io.jroIO_base import *
             ########## 2 Heredamos las propiedades de ProcessingUnit
             from schainpy.model.proc.jroproc_base import ProcessingUnit,Operation,MPDecorator
             ########## 3 Importaremos las clases BascicHeader, SystemHeader, RadarControlHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader,SystemHeader,RadarControllerHeader, ProcessingHeader
             ########## 4 Importaremos el objeto Voltge
             from schainpy.model.data.jrodata import Voltage
             @MPDecorator
             class SimulatorReader(JRODataReader, ProcessingUnit):
                 incIntFactor                   = 1
                 nFFTPoints                     = 0
                 FixPP_IncInt                   = 1
                 FixRCP_IPP                     = 1000
                 FixPP_CohInt                   = 1
                 Tau_0                          = 250
                 AcqH0_0                        = 70
                 H0                             = AcqH0_0
                 AcqDH_0                        = 1.25
                 DH0                            = AcqDH_0
                 Bauds                          = 32
                 BaudWidth                      = None
                 FixRCP_TXA                     = 40
                 FixRCP_TXB                     = 70
                 fAngle                         = 2.0*math.pi*(1/16)
                 DC_level                       = 500
                 stdev                          = 8
                 Num_Codes                      = 2
                 #code0                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
                 #code1                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
                 #Dyn_snCode                     = numpy.array([Num_Codes,Bauds])
                 Dyn_snCode                     = None
                 Samples                        = 200
                 channels                       = 5
                 pulses                         = None
                 Reference                      = None
                 pulse_size                     = None
                 prof_gen                       = None
                 Fdoppler                       = 100
                 Hdoppler                       = 36
+                Adoppler                       = 300
+                frequency                      = 9345
                 def __init__(self):
                     """
                     Inicializador de la clases SimulatorReader para
                     generar datos de voltage simulados.
                     Input:
                         dataOut: Objeto de la clase Voltage.
                         Este Objeto sera utilizado apra almacenar
                         un perfil de datos  cada vez qe se haga  psiversho
                         un requerimiento (getData)
                     """
                     ProcessingUnit.__init__(self)
                     print(" [ START ] init - Metodo Simulator Reader")
                     self.isConfig                  = False
                     self.basicHeaderObj            = BasicHeader(LOCALTIME)
                     self.systemHeaderObj           = SystemHeader()
                     self.radarControllerHeaderObj  = RadarControllerHeader()
                     self.processingHeaderObj       = ProcessingHeader()
                     self.profileIndex              = 2**32-1
                     self.dataOut                   = Voltage()
                     #code0                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1])
                     code0                          = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,-1,-1,1,1,1,-1,1])
                     #code1                          = numpy.array([1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0])
                     code1                          = numpy.array([1,1,1,-1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])
                     #self.Dyn_snCode                = numpy.array([code0,code1])
                     self.Dyn_snCode                = None
                     print(" [ END ] init - Metodo simulator Reader" )
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock* self.nTxs:
                         if self.nReadBlocks>0:
                             tmp                           = self.dataOut.utctime
                             tmp_utc                       = int(self.dataOut.utctime)
                             tmp_milisecond                = int((tmp-tmp_utc)*1000)
                             self.basicHeaderObj.utc       = tmp_utc
                             self.basicHeaderObj.miliSecond= tmp_milisecond
                         return 1
                     return 0
                 def setNextFile(self):
                     """Set the next file to be readed open it and parse de file header"""
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
-                        print('------------------- [Opening file] ------------------------------')
+                        self.nReadFiles=self.nReadFiles+1
+                        print('------------------- [Opening file] ------------------------------',self.nReadFiles)
                         self.nReadBlocks  = 0
                 def __setNewBlock(self):
                     self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                 def readNextBlock(self):
                     while True:
                         self.__setNewBlock()
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
                         break
                     if self.verbose:
                         print("[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                   self.dataOut.datatime.ctime()) )
                     return 1
                 def getFirstHeader(self):
                     self.getBasicHeader()
                     self.dataOut.processingHeaderObj      = self.processingHeaderObj.copy()
                     self.dataOut.systemHeaderObj          = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     #ADD NEW
                     self.dataOut.nProfiles   = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.heightList  = numpy.arange(self.processingHeaderObj.nHeights) * self.processingHeaderObj.deltaHeight + self.processingHeaderObj.firstHeight
                     self.dataOut.channelList = list(range(self.systemHeaderObj.nChannels))
                     self.dataOut.nCohInt     = self.processingHeaderObj.nCohInt
                     # asumo q la data no esta decodificada
                     self.dataOut.flagDecodeData  = self.processingHeaderObj.flag_decode
                     # asumo q la data no esta sin flip
                     self.dataOut.flagDeflipData  = self.processingHeaderObj.flag_deflip
                     self.dataOut.flagShiftFFT    = self.processingHeaderObj.shif_fft
+                    #
+                    self.dataOut.frequency = self.frequency
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
 . + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                 def reshapeData(self):
                     if self.nTxs==1:
                         return
                 def readBlock(self):
                     self.jro_GenerateBlockOfData(Samples= self.samples,DC_level=self.DC_level,
                                                  stdev=self.stdev,Reference= self.Reference,
                                                  pulses = self.pulses,Num_Codes=self.Num_Codes,
                                                  pulse_size=self.pulse_size,prof_gen=self.profiles,
                                                  H0=self.H0,DH0=self.DH0)
                     self.profileIndex   = 0
                     self.flagIsNewFile  = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks  += 1
                     self.nReadBlocks   += 1
                     return 1
                 def getData(self): ### metodo propio de VoltageReader
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNodata = True
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock         = 0
                     if self.__hasNotDataInBuffer():   # aqui es verdad
                         if not(self.readNextBlock()): # return 1 y por eso el if not salta  a getBasic Header
                             return 0
                         self.getFirstHeader()         # atributo
                         self.reshapeData()            # nTxx1 =1 return , n
                     if not self.getByBlock:
                         self.dataOut.flagDataAsBlock = False
                         self.dataOut.data = self.datablock[:, self.profileIndex, :]
                         self.dataOut.profileIndex = self.profileIndex
                         self.profileIndex += 1
                     else:
                         pass
                     self.dataOut.flagNoData = False
                     self.getBasicHeader()
                     self.dataOut.realtime = self.online
                     return self.dataOut.data
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def set_RCH(self, expType=2, nTx=1,ipp=None, txA=0, txB=0,
                              nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
                              numTaus=0, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=0, nCode=0, nBaud=0, code=None,
                              flip1=0, flip2=0):
                     self.radarControllerHeaderObj.expType      = expType
                     self.radarControllerHeaderObj.nTx          = nTx
                     self.radarControllerHeaderObj.ipp          = float(ipp)
                     self.radarControllerHeaderObj.txA          = float(txA)
                     self.radarControllerHeaderObj.txB          = float(txB)
                     self.radarControllerHeaderObj.rangeIPP     = ipp
                     self.radarControllerHeaderObj.rangeTxA     = txA
                     self.radarControllerHeaderObj.rangeTxB     = txB
                     self.radarControllerHeaderObj.nHeights     = int(nHeights)
                     self.radarControllerHeaderObj.firstHeight  = numpy.array([firstHeight])
                     self.radarControllerHeaderObj.deltaHeight  = numpy.array([deltaHeight])
                     self.radarControllerHeaderObj.samplesWin   = numpy.array([nHeights])
                     self.radarControllerHeaderObj.nWindows      = nWindows
                     self.radarControllerHeaderObj.numTaus       = numTaus
                     self.radarControllerHeaderObj.codeType      = codeType
                     self.radarControllerHeaderObj.line6Function = line6Function
                     self.radarControllerHeaderObj.line5Function = line5Function
                     self.radarControllerHeaderObj.fclock        = fClock
                     self.radarControllerHeaderObj.prePulseBefore= prePulseBefore
                     self.radarControllerHeaderObj.prePulseAfter = prePulseAfter
                     self.radarControllerHeaderObj.nCode = nCode
                     self.radarControllerHeaderObj.nBaud = nBaud
                     self.radarControllerHeaderObj.code  = code
                     self.radarControllerHeaderObj.flip1 = flip1
                     self.radarControllerHeaderObj.flip2 = flip2
                     self.radarControllerHeaderObj.code_size = int(numpy.ceil(nBaud / 32.)) * nCode * 4
                     if fClock is None and deltaHeight is not None:
                         self.fClock = 0.15 / (deltaHeight * 1e-6)
                 def set_PH(self, dtype=0, blockSize=0, profilesPerBlock=0,
                               dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
                               nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0,
                               deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
                               code=0, nBaud=None, shif_fft=False, flag_dc=False,
                               flag_cspc=False, flag_decode=False, flag_deflip=False):
                     self.processingHeaderObj.profilesPerBlock  = profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = dataBlocksPerFile
                     self.processingHeaderObj.nWindows          = nWindows
                     self.processingHeaderObj.nCohInt           = nCohInt
                     self.processingHeaderObj.nIncohInt         = nIncohInt
                     self.processingHeaderObj.totalSpectra      = totalSpectra
                     self.processingHeaderObj.nHeights          = int(nHeights)
                     self.processingHeaderObj.firstHeight       = firstHeight
                     self.processingHeaderObj.deltaHeight       = deltaHeight
                     self.processingHeaderObj.samplesWin        = nHeights
                 def set_BH(self, utc = 0, miliSecond = 0, timeZone = 0):
                     self.basicHeaderObj.utc                    = utc
                     self.basicHeaderObj.miliSecond             = miliSecond
                     self.basicHeaderObj.timeZone               = timeZone
                 def set_SH(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
                     self.systemHeaderObj.nSamples       = nSamples
                     self.systemHeaderObj.nProfiles      = nProfiles
                     self.systemHeaderObj.nChannels      = nChannels
                     self.systemHeaderObj.adcResolution  = adcResolution
                     self.systemHeaderObj.pciDioBusWidth = pciDioBusWidth
-                def setup(self,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,
+                def setup(self,frequency=49.92e6,incIntFactor= 1, nFFTPoints = 0, FixPP_IncInt=1,FixRCP_IPP=1000,
                                FixPP_CohInt= 1,Tau_0= 250,AcqH0_0 = 70 ,AcqDH_0=1.25, Bauds= 32,
-                               FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 500,
+                               FixRCP_TXA = 40, FixRCP_TXB = 50, fAngle = 2.0*math.pi*(1/16),DC_level= 50,
-                               stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,channels=1,Fdoppler=20,Hdoppler=36,
+                               stdev= 8,Num_Codes = 1 , Dyn_snCode = None, samples=200,
+                               channels=2,Fdoppler=20,Hdoppler=36,Adoppler=500,
                                **kwargs):
                     self.set_kwargs(**kwargs)
                     self.nReadBlocks = 0
+                    self.nReadFiles  = 1
+                    print('------------------- [Opening file: ] ------------------------------',self.nReadFiles)
                     tmp              = time.time()
                     tmp_utc          = int(tmp)
                     tmp_milisecond   = int((tmp-tmp_utc)*1000)
                     print(" SETUP -basicHeaderObj.utc",datetime.datetime.utcfromtimestamp(tmp))
                     if Dyn_snCode is None:
                         Num_Codes=1
                         Bauds    =1
                     self.set_BH(utc= tmp_utc,miliSecond= tmp_milisecond,timeZone=300 )
                     self.set_RCH( expType=0, nTx=150,ipp=FixRCP_IPP, txA=FixRCP_TXA, txB= FixRCP_TXB,
                              nWindows=1 , nHeights=samples, firstHeight=AcqH0_0, deltaHeight=AcqDH_0,
                              numTaus=1, line6Function=0, line5Function=0, fClock=None,
                              prePulseBefore=0, prePulseAfter=0,
                              codeType=14, nCode=Num_Codes, nBaud=32, code=Dyn_snCode,
                              flip1=0, flip2=0)
                     self.set_PH(dtype=0, blockSize=0, profilesPerBlock=300,
                                   dataBlocksPerFile=120, nWindows=1, processFlags=0, nCohInt=1,
                                   nIncohInt=1, totalSpectra=0, nHeights=samples, firstHeight=AcqH0_0,
                                   deltaHeight=AcqDH_0, samplesWin=samples, spectraComb=0, nCode=0,
                                   code=0, nBaud=None, shif_fft=False, flag_dc=False,
                                   flag_cspc=False, flag_decode=False, flag_deflip=False)
                     self.set_SH(nSamples=samples, nProfiles=300, nChannels=channels)
+                    self.frequency                      = frequency
                     self.incIntFactor                   = incIntFactor
                     self.nFFTPoints                     = nFFTPoints
                     self.FixPP_IncInt                   = FixPP_IncInt
                     self.FixRCP_IPP                     = FixRCP_IPP
                     self.FixPP_CohInt                   = FixPP_CohInt
                     self.Tau_0                          = Tau_0
                     self.AcqH0_0                        = AcqH0_0
                     self.H0                             = AcqH0_0
                     self.AcqDH_0                        = AcqDH_0
                     self.DH0                            = AcqDH_0
                     self.Bauds                          = Bauds
                     self.FixRCP_TXA                     = FixRCP_TXA
                     self.FixRCP_TXB                     = FixRCP_TXB
                     self.fAngle                         = fAngle
                     self.DC_level                       = DC_level
                     self.stdev                          = stdev
                     self.Num_Codes                      = Num_Codes
                     self.Dyn_snCode                     = Dyn_snCode
                     self.samples                        = samples
                     self.channels                       = channels
                     self.profiles                       = None
                     self.m_nReference                   = None
                     self.Baudwidth                      = None
                     self.Fdoppler                       = Fdoppler
                     self.Hdoppler                       = Hdoppler
+                    self.Adoppler                       = Adoppler
                     print("IPP    ", self.FixRCP_IPP)
                     print("Tau_0  ",self.Tau_0)
                     print("AcqH0_0",self.AcqH0_0)
                     print("samples,window ",self.samples)
                     print("AcqDH_0",AcqDH_0)
                     print("FixRCP_TXA",self.FixRCP_TXA)
                     print("FixRCP_TXB",self.FixRCP_TXB)
                     print("Dyn_snCode",Dyn_snCode)
                     print("Fdoppler", Fdoppler)
                     print("Hdoppler",Hdoppler)
+                    print("Vdopplermax",Fdoppler*(3.0e8/self.frequency)/2.0)
                     self.init_acquisition()
                     self.pulses,self.pulse_size=self.init_pulse(Num_Codes=self.Num_Codes,Bauds=self.Bauds,BaudWidth=self.BaudWidth,Dyn_snCode=Dyn_snCode)
                     print(" [ END ] - SETUP metodo")
                     return
                 def run(self,**kwargs): # metodo propio
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             ##################################################################
             ###### Aqui ingresamos las clases y metodos propios del simulador
             ##################################################################
             #############################################
             ############## INIT_ACQUISITION##############
             #############################################
                 def init_acquisition(self):
                     if self.nFFTPoints != 0:
                         self.incIntFactor = m_nProfilesperBlock/self.nFFTPoints
                         if (self.FixPP_IncInt > self.incIntFactor):
                             self.incIntFactor = self.FixPP_IncInt/ self.incIntFactor
                         elif(self.FixPP_IncInt< self.incIntFactor):
                             print("False alert...")
                     ProfilesperBlock  = self.processingHeaderObj.profilesPerBlock
                     self.timeperblock =int(((self.FixRCP_IPP
                                     *ProfilesperBlock
                                     *self.FixPP_CohInt
                                     *self.incIntFactor)
                                    /150.0)
                                   *0.9
                                   +0.5)
                     # para cada canal
                     self.profiles     =  ProfilesperBlock*self.FixPP_CohInt
                     self.profiles     =  ProfilesperBlock
                     self.Reference    =  int((self.Tau_0-self.AcqH0_0)/(self.AcqDH_0)+0.5)
                     self.BaudWidth    =  int((self.FixRCP_TXA/self.AcqDH_0)/self.Bauds + 0.5 )
                     if (self.BaudWidth==0):
                         self.BaudWidth=1
             #################################################################
             ####################### init_pulse ##############################
             ################################################################
                 def init_pulse(self,Num_Codes=Num_Codes,Bauds=Bauds,BaudWidth=BaudWidth,Dyn_snCode=Dyn_snCode):
                     Num_Codes   = Num_Codes
                     Bauds       = Bauds
                     BaudWidth   = BaudWidth
                     Dyn_snCode  = Dyn_snCode
                     if Dyn_snCode:
                         print("EXISTE")
                     else:
                         print("No existe")
                     if Dyn_snCode: # if Bauds:
                         pulses         = list(range(0,Num_Codes))
                         num_codes      = Num_Codes
                         for i in range(num_codes):
                             pulse_size = Bauds*BaudWidth
                             pulses[i]  = numpy.zeros(pulse_size)
                             for j in range(Bauds):
                                 for k in range(BaudWidth):
                                     pulses[i][j*BaudWidth+k] = int(Dyn_snCode[i][j]*600)
                     else:
                         print("sin code")
                         pulses     = list(range(1))
                         pulse_size = int(self.FixRCP_TXB/0.15+0.5)
                         pulses[0]  = numpy.ones(pulse_size)
                         pulses     = 600*pulses[0]
                     return pulses,pulse_size
             #################################################################
             ##################### Generate block data
             ################################################################
                 def jro_GenerateBlockOfData(self,Samples=Samples,DC_level= DC_level,stdev=stdev,
                                             Reference= Reference,pulses= pulses,
                                             Num_Codes= Num_Codes,pulse_size=pulse_size,
-                                            prof_gen= prof_gen,H0 = H0,DH0=DH0,Fdoppler= Fdoppler,Hdoppler=Hdoppler):
+                                            prof_gen= prof_gen,H0 = H0,DH0=DH0,
+                                            Adoppler=Adoppler,Fdoppler= Fdoppler,Hdoppler=Hdoppler):
                     Samples    = Samples
                     DC_level   = DC_level
                     stdev      = stdev
                     m_nR       = Reference
                     pulses     = pulses
                     num_codes  = Num_Codes
                     ps         = pulse_size
                     prof_gen   = prof_gen
                     channels   = self.channels
                     H0         = H0
                     DH0        = DH0
                     ippSec     = self.radarControllerHeaderObj.ippSeconds
                     Fdoppler   = self.Fdoppler
                     Hdoppler   = self.Hdoppler
+                    Adoppler   = self.Adoppler
                     self.datablock = numpy.zeros([channels,prof_gen,Samples],dtype= numpy.complex64)
                     for i in range(channels):
                         for k in range(prof_gen):
                             #·······················NOISE···············
                             Noise_r    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise_i    = numpy.random.normal(DC_level,stdev,Samples)
                             Noise      = numpy.zeros(Samples,dtype=complex)
                             Noise.real = Noise_r
                             Noise.imag = Noise_i
                             #·······················PULSOS··············
                             Pulso      = numpy.zeros(pulse_size,dtype=complex)
                             Pulso.real =  pulses[k%num_codes]
                             Pulso.imag =  pulses[k%num_codes]
                             #····················· PULSES+NOISE··········
                             InBuffer                    = numpy.zeros(Samples,dtype=complex)
                             InBuffer[m_nR:m_nR+ps]      = Pulso
-                            InBuffer                    = Noise+ InBuffer
+                            InBuffer                    =  InBuffer+Noise
                             #····················· ANGLE ·······························
                             InBuffer.real[m_nR:m_nR+ps] = InBuffer.real[m_nR:m_nR+ps]*(math.cos( self.fAngle)*5)
                             InBuffer.imag[m_nR:m_nR+ps] = InBuffer.imag[m_nR:m_nR+ps]*(math.sin( self.fAngle)*5)
                             InBuffer=InBuffer
                             self.datablock[i][k]= InBuffer
                             #plot_cts(InBuffer,H0=H0,DH0=DH0)
                             #wave_fft(x=InBuffer,plot_show=True)
                             #time.sleep(1)
                     #················DOPPLER SIGNAL...............................................
-                    time_vec   = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen
+                    time_vec   = numpy.linspace(0,(prof_gen-1)*ippSec,int(prof_gen))+self.nReadBlocks*ippSec*prof_gen+(self.nReadFiles-1)*ippSec*prof_gen
                     fd         = Fdoppler #+(600.0/120)*self.nReadBlocks
-                    d_signal   = 650*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
+                    d_signal   = Adoppler*numpy.array(numpy.exp(1.0j*2.0*math.pi*fd*time_vec),dtype=numpy.complex64)
                     #·················· DATABLOCK + DOPPLER············...........................
                     HD=int(Hdoppler/self.AcqDH_0)
-                    self.datablock[0,:,HD]=self.datablock[0,:,HD]+ d_signal # RESULT
+                    for  i in range(12):
+                        self.datablock[:,:,HD+i]=self.datablock[:,:,HD+i]+ d_signal # RESULT
                     '''
                     a= numpy.zeros(10)
                     for i in range(10):
                         a[i]=i+self.nReadBlocks+20
                     for i in a:
                         self.datablock[0,:,int(i)]=self.datablock[0,:,int(i)]+ d_signal # RESULT
                     '''

schainpy/model/proc/jroproc_spectra.py +1 -1

             import itertools
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, MPDecorator, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
             from schainpy.utils import log
             @MPDecorator
             class SpectraProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                     self.id_min = None
                     self.id_max = None
                     self.setupReq = False #Agregar a todas las unidades de proc
                 def __updateSpecFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     try:
                         self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
                     except:
                         pass
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
                     # asumo q la data esta decodificada
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData
                     # asumo q la data esta sin flip
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.realtime = self.dataIn.realtime
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                     """
                     fft_volt = numpy.fft.fft(
                         self.buffer, n=self.dataOut.nFFTPoints, axis=1)
                     fft_volt = fft_volt.astype(numpy.dtype('complex'))
                     dc = fft_volt[:, 0, :]
                     # calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt, axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     #print("spcch0",spc[0])
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     #print("spc                                   :",spc.shape)
                     data_wr = None
                     if self.dataOut.flagWR:
-                        data_wr   = fft_volt
+                        data_wr   = self.buffer
                         blocksize = fft_volt.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         # calculo de cross-spectra
                         cspc = numpy.zeros(
                             (self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
                                 raise ValueError("Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
                                     str(pair), str(self.dataOut.channelList)))
                             if pair[1] not in self.dataOut.channelList:
                                 raise ValueError("Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
                                     str(pair), str(self.dataOut.channelList)))
                             cspc[pairIndex, :, :] = fft_volt[pair[0], :, :] * \
                                 numpy.conjugate(fft_volt[pair[1], :, :])
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc     = spc
                     self.dataOut.data_cspc    = cspc
                     self.dataOut.data_wr      = data_wr
                     self.dataOut.data_dc      = dc
                     self.dataOut.blockSize    = blocksize
                     self.dataOut.flagShiftFFT = False
                 def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None, shift_fft=False,flagWR= 0):
                     self.dataOut.flagWR = flagWR
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         if shift_fft:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             shift = int(self.dataOut.nFFTPoints/2)
                             self.dataOut.data_spc = numpy.roll(self.dataOut.data_spc, shift , axis=1)
                             if self.dataOut.data_cspc is not None:
                                 #desplaza a la derecha en el eje 2 determinadas posiciones
                                 self.dataOut.data_cspc = numpy.roll(self.dataOut.data_cspc, shift, axis=1)
                         return True
                     if self.dataIn.type == "Voltage":
                         #print("VOLTAGE INPUT SPECTRA")
                         self.dataOut.flagNoData = True
                         if nFFTPoints == None:
                             raise ValueError("This SpectraProc.run() need nFFTPoints input variable")
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                         if ippFactor == None:
                             ippFactor = 1
                         self.dataOut.ippFactor = ippFactor
                         self.dataOut.nFFTPoints = nFFTPoints
                         self.dataOut.pairsList = pairsList
                         if self.buffer is None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                        nProfiles,
                                                        self.dataIn.nHeights),
                                                       dtype='complex')
                             #print("buffer                            :",self.buffer.shape)
                         if self.dataIn.flagDataAsBlock:
                             nVoltProfiles = self.dataIn.data.shape[1]
                             if nVoltProfiles == nProfiles:
                                 self.buffer = self.dataIn.data.copy()
                                 self.profIndex = nVoltProfiles
                             elif nVoltProfiles < nProfiles:
                                 if self.profIndex == 0:
                                     self.id_min = 0
                                     self.id_max = nVoltProfiles
                                 self.buffer[:, self.id_min:self.id_max,
                                             :] = self.dataIn.data
                                 self.profIndex += nVoltProfiles
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
                                 raise ValueError("The type object %s has %d profiles, it should just has %d profiles" % (
                                     self.dataIn.type, self.dataIn.data.shape[1], nProfiles))
                                 self.dataOut.flagNoData = True
                                 return 0
                         else:
                             #print("Spectra ",self.profIndex)
                             self.buffer[:, self.profIndex, :] = self.dataIn.data.copy()
                             self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == nProfiles:
                             self.__updateSpecFromVoltage()
                             self.__getFft()
                             #print(" DATAOUT SHAPE SPEC",self.dataOut.data_spc.shape)
                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
                         return True
                     raise ValueError("The type of input object '%s' is not valid" % (
                         self.dataIn.type))
                 def __selectPairs(self, pairsList):
                     if not pairsList:
                         return
                     pairs = []
                     pairsIndex = []
                     for pair in pairsList:
                         if pair[0] not in self.dataOut.channelList or pair[1] not in self.dataOut.channelList:
                             continue
                         pairs.append(pair)
                         pairsIndex.append(pairs.index(pair))
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
                     self.dataOut.pairsList = pairs
                     return
                 def __selectPairsByChannel(self, channelList=None):
                     if channelList == None:
                         return
                     pairsIndexListSelected = []
                     for pairIndex in self.dataOut.pairsIndexList:
                         # First pair
                         if self.dataOut.pairsList[pairIndex][0] not in channelList:
                             continue
                         # Second pair
                         if self.dataOut.pairsList[pairIndex][1] not in channelList:
                             continue
                         pairsIndexListSelected.append(pairIndex)
                     if not pairsIndexListSelected:
                         self.dataOut.data_cspc = None
                         self.dataOut.pairsList = []
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
                     self.dataOut.pairsList = [self.dataOut.pairsList[i]
                                               for i in pairsIndexListSelected]
                     return
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError("Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" % (
                                 channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError("Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " % (
                                 channelIndex, self.dataOut.channelIndexList))
                     data_spc = self.dataOut.data_spc[channelIndexList, :]
                     data_dc = self.dataOut.data_dc[channelIndexList, :]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_dc = data_dc
                     # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     self.dataOut.channelList = range(len(channelIndexList))
                     self.__selectPairsByChannel(channelIndexList)
                     return 1
                 def selectFFTs(self, minFFT, maxFFT ):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de puntos FFTs segun el rango
                     minFFT<= FFT <= maxFFT
                     """
                     if (minFFT > maxFFT):
                         raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minFFT, maxFFT))
                     if (minFFT < self.dataOut.getFreqRange()[0]):
                         minFFT = self.dataOut.getFreqRange()[0]
                     if (maxFFT > self.dataOut.getFreqRange()[-1]):
                         maxFFT = self.dataOut.getFreqRange()[-1]
                     minIndex = 0
                     maxIndex = 0
                     FFTs = self.dataOut.getFreqRange()
                     inda = numpy.where(FFTs >= minFFT)
                     indb = numpy.where(FFTs <= maxFFT)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(FFTs)
                     self.selectFFTsByIndex(minIndex, maxIndex)
                     return 1
                 def setH0(self, h0, deltaHeight = None):
                     if not deltaHeight:
                         deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     nHeights = self.dataOut.nHeights
                     newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
                     self.dataOut.heightList = newHeiRange
                 def selectHeights(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minHei > maxHei):
                         raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei))
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def getBeaconSignal(self, tauindex=0, channelindex=0, hei_ref=None):
                     newheis = numpy.where(
                         self.dataOut.heightList > self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                     if hei_ref != None:
                         newheis = numpy.where(self.dataOut.heightList > hei_ref)
                     minIndex = min(newheis[0])
                     maxIndex = max(newheis[0])
                     data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
                     heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     # determina indices
                     nheis = int(self.dataOut.radarControllerHeaderObj.txB /
                                 (self.dataOut.heightList[1] - self.dataOut.heightList[0]))
                     avg_dB = 10 * \
                         numpy.log10(numpy.sum(data_spc[channelindex, :, :], axis=0))
                     beacon_dB = numpy.sort(avg_dB)[-nheis:]
                     beacon_heiIndexList = []
                     for val in avg_dB.tolist():
                         if val >= beacon_dB[0]:
                             beacon_heiIndexList.append(avg_dB.tolist().index(val))
                     #data_spc = data_spc[:,:,beacon_heiIndexList]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
                         #data_cspc = data_cspc[:,:,beacon_heiIndexList]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
                         #data_dc = data_dc[:,beacon_heiIndexList]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = heightList
                     self.dataOut.beacon_heiIndexList = beacon_heiIndexList
                     return 1
                 def selectFFTsByIndex(self, minIndex, maxIndex):
                     """
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nProfiles):
                         maxIndex = self.dataOut.nProfiles-1
                     #Spectra
                     data_spc = self.dataOut.data_spc[:,minIndex:maxIndex+1,:]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,minIndex:maxIndex+1,:]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[minIndex:maxIndex+1,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.ippSeconds = self.dataOut.ippSeconds*(self.dataOut.nFFTPoints / numpy.shape(data_cspc)[1])
                     self.dataOut.nFFTPoints = numpy.shape(data_cspc)[1]
                     self.dataOut.profilesPerBlock = numpy.shape(data_cspc)[1]
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
                             minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     # Spectra
                     data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     return 1
                 def removeDC(self, mode=2):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     if jcspectra is not None:
                         jcspectraExist = True
                         num_pairs = jcspectra.shape[0]
                     else:
                         jcspectraExist = False
                     freq_dc = int(jspectra.shape[1] / 2)
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     ind_vel = ind_vel.astype(int)
                     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 jcspectraExist:
                             jcspectra[:, freq_dc, :] = (
                                 jcspectra[:, ind_vel[1], :] + jcspectra[:, ind_vel[2], :]) / 2
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
                             xx[fil, :] = vel[fil]**numpy.asarray(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
                         if jcspectraExist:
                             for ip in range(num_pairs):
                                 yy = jcspectra[ip, ind_vel, :]
                                 jcspectra[ip, freq_dc, :] = numpy.dot(xx_aux, yy)
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def removeInterference2(self):
                     cspc = self.dataOut.data_cspc
                     spc = self.dataOut.data_spc
                     Heights = numpy.arange(cspc.shape[2])
                     realCspc = numpy.abs(cspc)
                     for i in range(cspc.shape[0]):
                         LinePower= numpy.sum(realCspc[i], axis=0)
                         Threshold = numpy.amax(LinePower)-numpy.sort(LinePower)[len(Heights)-int(len(Heights)*0.1)]
                         SelectedHeights = Heights[ numpy.where( LinePower < Threshold ) ]
                         InterferenceSum = numpy.sum( realCspc[i,:,SelectedHeights], axis=0 )
                         InterferenceThresholdMin = numpy.sort(InterferenceSum)[int(len(InterferenceSum)*0.98)]
                         InterferenceThresholdMax = numpy.sort(InterferenceSum)[int(len(InterferenceSum)*0.99)]
                         InterferenceRange = numpy.where( ([InterferenceSum > InterferenceThresholdMin]))# , InterferenceSum < InterferenceThresholdMax]) )
                         #InterferenceRange = numpy.where( ([InterferenceRange < InterferenceThresholdMax]))
                         if len(InterferenceRange)<int(cspc.shape[1]*0.3):
                             cspc[i,InterferenceRange,:] = numpy.NaN
                     self.dataOut.data_cspc = cspc
                 def removeInterference(self,  interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     jnoise = self.dataOut.getNoise()
                     num_incoh = self.dataOut.nIncohInt
                     num_channel = jspectra.shape[0]
                     num_prof = jspectra.shape[1]
                     num_hei = jspectra.shape[2]
                     # hei_interf
                     if hei_interf is None:
                         count_hei = int(num_hei / 2)
                         hei_interf = numpy.asmatrix(list(range(count_hei))) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     # nhei_interf
                     if (nhei_interf == None):
                         nhei_interf = 5
                     if (nhei_interf < 1):
                         nhei_interf = 1
                     if (nhei_interf > count_hei):
                         nhei_interf = count_hei
                     if (offhei_interf == None):
                         offhei_interf = 0
                     ind_hei = list(range(num_hei))
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
                     mask_prof = numpy.asarray(list(range(num_prof)))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof / 2]
                     # noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
                     if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
                         jnoise = numpy.nan
                     noise_exist = jnoise[0] < numpy.Inf
                     # Subrutina de Remocion de la Interferencia
                     for ich in range(num_channel):
                         # Se ordena los espectros segun su potencia (menor a mayor)
                         power = jspectra[ich, mask_prof, :]
                         power = power[:, hei_interf]
                         power = power.sum(axis=0)
                         psort = power.ravel().argsort()
                         # Se estima la interferencia promedio en los Espectros de Potencia empleando
                         junkspc_interf = jspectra[ich, :, hei_interf[psort[list(range(
                             offhei_interf, nhei_interf + offhei_interf))]]]
                         if noise_exist:
                             #    tmp_noise = jnoise[ich] / num_prof
                             tmp_noise = jnoise[ich]
                         junkspc_interf = junkspc_interf - tmp_noise
                         #junkspc_interf[:,comp_mask_prof] = 0
                         jspc_interf = junkspc_interf.sum(axis=0) / nhei_interf
                         jspc_interf = jspc_interf.transpose()
                         # Calculando el espectro de interferencia promedio
                         noiseid = numpy.where(
                             jspc_interf <= tmp_noise / numpy.sqrt(num_incoh))
                         noiseid = noiseid[0]
                         cnoiseid = noiseid.size
                         interfid = numpy.where(
                             jspc_interf > tmp_noise / numpy.sqrt(num_incoh))
                         interfid = interfid[0]
                         cinterfid = interfid.size
                         if (cnoiseid > 0):
                             jspc_interf[noiseid] = 0
                         # Expandiendo los perfiles a limpiar
                         if (cinterfid > 0):
                             new_interfid = (
                                 numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof) % num_prof
                             new_interfid = numpy.asarray(new_interfid)
                             new_interfid = {x for x in new_interfid}
                             new_interfid = numpy.array(list(new_interfid))
                             new_cinterfid = new_interfid.size
                         else:
                             new_cinterfid = 0
                         for ip in range(new_cinterfid):
                             ind = junkspc_interf[:, new_interfid[ip]].ravel().argsort()
                             jspc_interf[new_interfid[ip]
                                         ] = junkspc_interf[ind[nhei_interf // 2], new_interfid[ip]]
                         jspectra[ich, :, ind_hei] = jspectra[ich, :,
                                                              ind_hei] - jspc_interf  # Corregir indices
                         # Removiendo la interferencia del punto de mayor interferencia
                         ListAux = jspc_interf[mask_prof].tolist()
                         maxid = ListAux.index(max(ListAux))
                         if cinterfid > 0:
                             for ip in range(cinterfid * (interf == 2) - 1):
                                 ind = (jspectra[ich, interfid[ip], :] < tmp_noise *
                                        (1 + 1 / numpy.sqrt(num_incoh))).nonzero()
                                 cind = len(ind)
                                 if (cind > 0):
                                     jspectra[ich, interfid[ip], ind] = tmp_noise * \
                                         (1 + (numpy.random.uniform(cind) - 0.5) /
                                          numpy.sqrt(num_incoh))
                             ind = numpy.array([-2, -1, 1, 2])
                             xx = numpy.zeros([4, 4])
                             for id1 in range(4):
                                 xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:, 0]
                             ind = (ind + maxid + num_mask_prof) % num_mask_prof
                             yy = jspectra[ich, mask_prof[ind], :]
                             jspectra[ich, mask_prof[maxid], :] = numpy.dot(
                                 yy.transpose(), xx)
                         indAux = (jspectra[ich, :, :] < tmp_noise *
                                   (1 - 1 / numpy.sqrt(num_incoh))).nonzero()
                         jspectra[ich, indAux[0], indAux[1]] = tmp_noise * \
                             (1 - 1 / numpy.sqrt(num_incoh))
                     # Remocion de Interferencia en el Cross Spectra
                     if jcspectra is None:
                         return jspectra, jcspectra
                     num_pairs = int(jcspectra.size / (num_prof * num_hei))
                     jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
                     for ip in range(num_pairs):
                         #-------------------------------------------
                         cspower = numpy.abs(jcspectra[ip, mask_prof, :])
                         cspower = cspower[:, hei_interf]
                         cspower = cspower.sum(axis=0)
                         cspsort = cspower.ravel().argsort()
                         junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[list(range(
                             offhei_interf, nhei_interf + offhei_interf))]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
                         median_real = int(numpy.median(numpy.real(
                             junkcspc_interf[mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
                         median_imag = int(numpy.median(numpy.imag(
                             junkcspc_interf[mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
                         comp_mask_prof = [int(e) for e in comp_mask_prof]
                         junkcspc_interf[comp_mask_prof, :] = numpy.complex(
                             median_real, median_imag)
                         for iprof in range(num_prof):
                             ind = numpy.abs(junkcspc_interf[iprof, :]).ravel().argsort()
                             jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf // 2]]
                         # Removiendo la Interferencia
                         jcspectra[ip, :, ind_hei] = jcspectra[ip,
                                                               :, ind_hei] - jcspc_interf
                         ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
                         maxid = ListAux.index(max(ListAux))
                         ind = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for id1 in range(4):
                             xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:, 0]
                         ind = (ind + maxid + num_mask_prof) % num_mask_prof
                         yy = jcspectra[ip, mask_prof[ind], :]
                         jcspectra[ip, mask_prof[maxid], :] = numpy.dot(yy.transpose(), xx)
                     # Guardar Resultados
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def setRadarFrequency(self, frequency=None):
                     if frequency != None:
                         self.dataOut.frequency = frequency
                     return 1
                 def getNoise(self, minHei=None, maxHei=None, minVel=None, maxVel=None):
                     # validacion de rango
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                     if maxHei == None:
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                         print('minHei: %.2f is out of the heights range' % (minHei))
                         print('minHei is setting to %.2f' % (self.dataOut.heightList[0]))
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
                         print('maxHei: %.2f is out of the heights range' % (maxHei))
                         print('maxHei is setting to %.2f' % (self.dataOut.heightList[-1]))
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                     velrange = self.dataOut.getVelRange(1)
                     if minVel == None:
                         minVel = velrange[0]
                     if maxVel == None:
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
                         print('minVel: %.2f is out of the velocity range' % (minVel))
                         print('minVel is setting to %.2f' % (velrange[0]))
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
                         print('maxVel: %.2f is out of the velocity range' % (maxVel))
                         print('maxVel is setting to %.2f' % (velrange[-1]))
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("some value in (%d,%d) is not valid" % (
                             minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     # seleccion de indices para velocidades
                     indminvel = numpy.where(velrange >= minVel)
                     indmaxvel = numpy.where(velrange <= maxVel)
                     try:
                         minIndexVel = indminvel[0][0]
                     except:
                         minIndexVel = 0
                     try:
                         maxIndexVel = indmaxvel[0][-1]
                     except:
                         maxIndexVel = len(velrange)
                     # seleccion del espectro
                     data_spc = self.dataOut.data_spc[:,
                                                      minIndexVel:maxIndexVel + 1, minIndex:maxIndex + 1]
                     # estimacion de ruido
                     noise = numpy.zeros(self.dataOut.nChannels)
                     for channel in range(self.dataOut.nChannels):
                         daux = data_spc[channel, :, :]
                         noise[channel] = hildebrand_sekhon(daux, self.dataOut.nIncohInt)
                     self.dataOut.noise_estimation = noise.copy()
                     return 1
             class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer_spc = None
                 __buffer_cspc = None
                 __buffer_dc = None
                 __dataReady = False
                 __timeInterval = None
                 n = None
                 def __init__(self):
                     Operation.__init__(self)
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     self.__dataReady = False
                     self.__byTime = False
                     if n is None and timeInterval is None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n is not None:
                         self.n = int(n)
                     else:
                         self.__integrationtime = int(timeInterval)
                         self.n = None
                         self.__byTime = True
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                     """
                     print("profIndex:      ",self.__profIndex)
                     print("data_spc.shape: ",data_spc.shape)
                     print("data_spc.shape: ",data_spc[0,0,:])
                     self.__buffer_spc += data_spc
                     if data_cspc is None:
                         self.__buffer_cspc = None
                     else:
                         self.__buffer_cspc += data_cspc
                     if data_dc is None:
                         self.__buffer_dc = None
                     else:
                         self.__buffer_dc += data_dc
                     self.__profIndex += 1
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     data_spc = self.__buffer_spc
                     data_cspc = self.__buffer_cspc
                     data_dc = self.__buffer_dc
                     n = self.__profIndex
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if self.__profIndex == self.n:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def byTime(self, datatime, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def integrate(self, datatime, *args):
                     if self.__profIndex == 0:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(
                             datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                     if not self.__dataReady:
                         return None, None, None, None
                     return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if n == 1:
                         return
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.isConfig = True
                     avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                         dataOut.data_spc,
                                                                                         dataOut.data_cspc,
                                                                                         dataOut.data_dc)
                     if self.__dataReady:
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False
                     return dataOut
             class PulsePair(Operation):
                 isConfig       = False
                 __profIndex    = 0
                 __profIndex2   = 0
                 __initime      = None
                 __lastdatatime = None
                 __buffer       = None
                 __buffer2      = []
                 __buffer3      = None
                 __dataReady    = False
                 n              = None
                 __nch          =0
                 __nProf        =0
                 __nHeis        =0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                 def setup(self,dataOut,n =None, m = None):
                     self.__initime      = None
                     self.__lastdatatime = 0
                     self.__buffer         = 0
                     self.__bufferV        = 0
                     #self.__buffer2        = []
                     self.__buffer3        = 0
                     self.__dataReady      = False
                     self.__profIndex      = 0
                     self.__profIndex2     = 0
                     self.count            = 0
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
                     self.__nProf          = dataOut.nProfiles
                     self.__nFFT           = dataOut.nFFTPoints
                     #print("Valores de Ch,Samples,Perfiles,nFFT",self.__nch,self.__nHeis,self.__nProf, self.__nFFT)
                     #print("EL VALOR DE n es:",n)
                     if n == None:
                         raise ValueError("n Should be specified.")
                     if n != None:
                         if n<2:
                             raise ValueError("n Should be greather than 2 ")
                     self.n                = n
                     if m == None:
                         m = n
                     if m != None:
                         if  m<2:
                             raise ValueError("n Should be greather than 2 ")
                     self.m               = m
                     self.__buffer2        = numpy.zeros((self.__nch,self.m,self.__nHeis))
                     self.__bufferV2       = numpy.zeros((self.__nch,self.m,self.__nHeis))
                 def putData(self,data):
                     #print("###################################################")
                     '''
                     data_tmp   =    numpy.zeros(self.__nch,self.n,self.__nHeis, dtype= complex)
                     if self.count < self.__nProf:
                         for i in range(self.n):
                             data_tmp[:,i,:]    =  data[:,i+self.count,:]
                         self.__buffer          =  data_tmp*numpy.conjugate(data_tmp)
                     #####self.__buffer          = data*numpy.conjugate(data)
                     #####self.__bufferV         = data[:,(self.__nProf-1):,:]*numpy.conjugate(data[:,1:,:])
                     #self.__buffer2.append(numpy.conjugate(data))
                     #####self.__profIndex        = data.shape[1]
                     self.count              = self.count + self.n -1
                     self.__profIndex        = self.n
                     '''
                     self.__buffer          = data*numpy.conjugate(data)
                     self.__bufferV         = data[:,(self.__nProf-1):,:]*numpy.conjugate(data[:,1:,:])
                     self.__profIndex        = self.n
                     #print("spcch0",self.__buffer)
                     return
                 def pushData(self):
                     data_I           = numpy.zeros((self.__nch,self.__nHeis))
                     data_IV          = numpy.zeros((self.__nch,self.__nHeis))
                     for i in range(self.__nch):
                         data_I[i,:]  = numpy.sum(self.__buffer[i],axis=0)/self.n
                         data_IV[i,:] = numpy.sum(self.__bufferV[i],axis=0)/(self.n-1)
                     ##print("******")
                     #print("data_I",data_I[0])
                     #print(self.__buffer.shape)
                     #a=numpy.average(self.__buffer,axis=1)
                     #print("average", a)
                     n                = self.__profIndex
                     ####data_intensity = numpy.sum(numpy.sum(self.__buffer,axis=0),axis=0)/self.n
                     #print("data_intensity push data",data_intensity.shape)
                     #data_velocity  = self.__buffer3/(self.n-1)
                     ####n              = self.__profIndex
                     self.__buffer    = 0
                     self.__buffer3   = 0
                     self.__profIndex = 0
                     #return data_intensity,data_velocity,n
                     return data_I,data_IV,n
                 def pulsePairbyProfiles(self,data):
                     self.__dataReady      = False
                     data_intensity        = None
                     data_velocity         = None
                     self.putData(data)
                     if self.__profIndex == self.n:
                         #data_intensity,data_velocity,n = self.pushData()
                         data_intensity,data_velocity,n = self.pushData()
                         #print(data_intensity.shape)
                         #print("self.__profIndex2", self.__profIndex2)
                         if self.__profIndex2 == 0:
                             #print("PRIMERA VEZ")
                             #print("self.__buffer2",self.__buffer2)
                             for i in range(self.__nch):
                                 self.__buffer2[i][self.__profIndex2]  = data_intensity[i]
                                 self.__bufferV2[i][self.__profIndex2] = data_velocity[i]
                             self.__profIndex2       += 1
                             return None,None
                         if self.__profIndex2 > 0:
                             for i in range(self.__nch):
                                 self.__buffer2[i][self.__profIndex2]  = data_intensity[i]
                                 self.__bufferV2[i][self.__profIndex2] = data_velocity[i]
                             #print("Dentro del bucle",self.__buffer2)
                             self.__profIndex2       += 1
                             if self.__profIndex2 == self.m :
                                 data_i                         = self.__buffer2
                                 data_v                         = self.__bufferV2
                                 #print(data_i.shape)
                                 self.__dataReady               = True
                                 self.__profIndex2              = 0
                                 self.__buffer2                 = numpy.zeros((self.__nch,self.m,self.__nHeis))
                                 self.__bufferV2                = numpy.zeros((self.__nch,self.m,self.__nHeis))
                                 return data_i,data_v
                             return  None,None
                 def pulsePairOp(self,data,datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     data_intensity,data_velocity = self.pulsePairbyProfiles(data)
                     self.__lastdatatime           = datatime
                     if data_intensity is None:
                         return None,None,None
                     avgdatatime    = self.__initime
                     self.__initime = datatime
                     return data_intensity,data_velocity,avgdatatime
                 def run(self,dataOut,n =None,m=None):
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, n   = n, m = m)
                         self.isConfig  = True
                     data_intensity,data_velocity,avgdatatime  = self.pulsePairOp(dataOut.data_wr,dataOut.utctime)
                     dataOut.flagNoData                          = True
                     if self.__dataReady:
                         #print(" DATA " , data_intensity.shape)
                         #dataOut.data            = numpy.array([data_intensity])#aqui amigo revisa
                         #tmp                     = numpy.zeros([1,data_intensity.shape[0],data_intensity.shape[1]])
                         #tmp[0]                  = data_intensity
                         dataOut.data            = data_intensity
                         dataOut.data_velocity   = data_velocity
                         #dataOut.data            = tmp
                         #print(" DATA " , dataOut.data.shape)
                         dataOut.nIncohInt      *= self.n
                         dataOut.nProfiles       = self.m
                         dataOut.nFFTPoints      = self.m
                         #dataOut.data_intensity  = data_intensity
                         dataOut.PRFbyAngle      = self.n
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                         #####print("TIEMPO:                     ",dataOut.utctime)
                     return dataOut

schainpy/model/proc/jroproc_voltage.py +42 -234

             import sys
-            import numpy
+            import time
+            import numpy,math
             from scipy import interpolate
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import Voltage
             from schainpy.utils import log
             from time import time
             @MPDecorator
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Voltage()
                     self.flip = 1
                     self.setupReq = False
                 def run(self):
                     if self.dataIn.type == 'AMISR':
                         self.__updateObjFromAmisrInput()
                     if self.dataIn.type == 'Voltage':
                         self.dataOut.copy(self.dataIn)
                 #         self.dataOut.copy(self.dataIn)
                 def __updateObjFromAmisrInput(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.flagNoData = self.dataIn.flagNoData
                     self.dataOut.data = self.dataIn.data
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.channelList = self.dataIn.channelList
                     #self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.nProfiles = self.dataIn.nProfiles
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
                 #
                 #        pass#
                 #
                 #    def init(self):
                 #
                 #
                 #        if self.dataIn.type == 'AMISR':
                 #            self.__updateObjFromAmisrInput()
                 #
                 #        if self.dataIn.type == 'Voltage':
                 #            self.dataOut.copy(self.dataIn)
                 #        # No necesita copiar en cada init() los atributos de dataIn
                 #        # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             print(channelIndexList)
                             raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
                     if self.dataOut.flagDataAsBlock:
                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         data = self.dataOut.data[channelIndexList,:,:]
                     else:
                         data = self.dataOut.data[channelIndexList,:]
                     self.dataOut.data = data
                     # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     self.dataOut.channelList = range(len(channelIndexList))
                     return 1
                 def selectHeights(self, minHei=None, maxHei=None):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                     if maxHei == None:
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights
                     #voltage
                     if self.dataOut.flagDataAsBlock:
                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         data = self.dataOut.data[:,:, minIndex:maxIndex]
                     else:
                         data = self.dataOut.data[:, minIndex:maxIndex]
                     #         firstHeight = self.dataOut.heightList[minIndex]
                     self.dataOut.data = data
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
                     if self.dataOut.nHeights <= 1:
                         raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
                     return 1
                 def filterByHeights(self, window):
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     if window == None:
                         window = (self.dataOut.radarControllerHeaderObj.txA/self.dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
                     newdelta = deltaHeight * window
                     r = self.dataOut.nHeights % window
                     newheights = (self.dataOut.nHeights-r)/window
                     if newheights <= 1:
                         raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(self.dataOut.nHeights, window))
                     if self.dataOut.flagDataAsBlock:
                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         buffer = self.dataOut.data[:, :, 0:int(self.dataOut.nHeights-r)]
                         buffer = buffer.reshape(self.dataOut.nChannels, self.dataOut.nProfiles, int(self.dataOut.nHeights/window), window)
                         buffer = numpy.sum(buffer,3)
                     else:
                         buffer = self.dataOut.data[:,0:int(self.dataOut.nHeights-r)]
                         buffer = buffer.reshape(self.dataOut.nChannels,int(self.dataOut.nHeights/window),int(window))
                         buffer = numpy.sum(buffer,2)
                     self.dataOut.data = buffer
                     self.dataOut.heightList = self.dataOut.heightList[0] + numpy.arange( newheights )*newdelta
                     self.dataOut.windowOfFilter = window
                 def setH0(self, h0, deltaHeight = None):
                     if not deltaHeight:
                         deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     nHeights = self.dataOut.nHeights
                     newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
                     self.dataOut.heightList = newHeiRange
                 def deFlip(self, channelList = []):
                     data = self.dataOut.data.copy()
                     if self.dataOut.flagDataAsBlock:
                         flip = self.flip
                         profileList = list(range(self.dataOut.nProfiles))
                         if not channelList:
                             for thisProfile in profileList:
                                 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
                                 flip *= -1.0
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in self.dataOut.channelList:
                                     continue
                                 for thisProfile in profileList:
                                     data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
                                     flip *= -1.0
                         self.flip = flip
                     else:
                         if not channelList:
                             data[:,:] = data[:,:]*self.flip
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in self.dataOut.channelList:
                                     continue
                                 data[thisChannel,:] = data[thisChannel,:]*self.flip
                         self.flip *= -1.
                     self.dataOut.data = data
                 def setRadarFrequency(self, frequency=None):
                     if frequency != None:
                         self.dataOut.frequency = frequency
                     return 1
                 def interpolateHeights(self, topLim, botLim):
                     #69 al 72 para julia
                     #82-84 para meteoros
                     if len(numpy.shape(self.dataOut.data))==2:
                         sampInterp = (self.dataOut.data[:,botLim-1] + self.dataOut.data[:,topLim+1])/2
                         sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
                         #self.dataOut.data[:,botLim:limSup+1] = sampInterp
                         self.dataOut.data[:,botLim:topLim+1] = sampInterp
                     else:
                         nHeights = self.dataOut.data.shape[2]
                         x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
                         y = self.dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
                         f = interpolate.interp1d(x, y, axis = 2)
                         xnew = numpy.arange(botLim,topLim+1)
                         ynew = f(xnew)
                         self.dataOut.data[:,:,botLim:topLim+1]  = ynew
                 # import collections
             class CohInt(Operation):
                 isConfig = False
                 __profIndex = 0
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __bufferStride = []
                 __dataReady = False
                 __profIndexStride = 0
                 __dataToPutStride = False
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     #   self.isConfig = False
                 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n               :    Number of coherent integrations
                         timeInterval    :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping     :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     self.byblock = byblock
                     self.stride = stride
                     if n == None and timeInterval == None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverlapping = True
                         self.__buffer = None
                     else:
                         self.__withOverlapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverlapping:
-                        print("inside over")
+                        #print("inside over")
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
-                    print("show me the light",data.shape)
+                    #print("show me the light",data.shape)
                     data = numpy.reshape(data, (1, nChannels, nHeis))
-                    print(data.shape)
+                    #print(data.shape)
                     #If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverlapping:
-                        #print("ahora que fue")
+                        print("ahora que fue")
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #print("cual funciona")
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     # print data
                     # raise
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
                     #         n = None
                     # print data
                     # raise
                     #print("beforeputdata")
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrateByStride(self, data, datatime):
                     # print data
                     if self.__profIndex == 0:
                         self.__buffer = [[data.copy(), datatime]]
                     else:
                         self.__buffer.append([data.copy(),datatime])
                     self.__profIndex += 1
                     self.__dataReady = False
                     if self.__profIndex == self.n * self.stride :
                         self.__dataToPutStride = True
                         self.__profIndexStride = 0
                         self.__profIndex = 0
                         self.__bufferStride = []
                         for i in range(self.stride):
                             current = self.__buffer[i::self.stride]
                             data = numpy.sum([t[0] for t in current], axis=0)
                             avgdatatime = numpy.average([t[1] for t in current])
                             # print data
                             self.__bufferStride.append((data, avgdatatime))
                     if self.__dataToPutStride:
                         self.__dataReady = True
                         self.__profIndexStride += 1
                         if self.__profIndexStride == self.stride:
                             self.__dataToPutStride = False
                         # print self.__bufferStride[self.__profIndexStride - 1]
                         # raise
                         return self.__bufferStride[self.__profIndexStride - 1]
                     return None, None
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata is None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime - self.__lastdatatime
                     if not self.__withOverlapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def integrateByBlock(self, dataOut):
                     times = int(dataOut.data.shape[1]/self.n)
                     avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
                     id_min = 0
                     id_max = self.n
                     for i in range(times):
                         junk = dataOut.data[:,id_min:id_max,:]
                         avgdata[:,i,:] = junk.sum(axis=1)
                         id_min += self.n
                         id_max += self.n
                     timeInterval = dataOut.ippSeconds*self.n
                     avgdatatime = (times - 1) * timeInterval + dataOut.utctime
                     self.__dataReady = True
                     return avgdata, avgdatatime
                 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
                     if not self.isConfig:
                         self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         avgdata, avgdatatime = self.integrateByBlock(dataOut)
                         dataOut.nProfiles /= self.n
                     else:
                         if stride is None:
                             avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
                         else:
                             avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
                     #   dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         dataOut.nCohInt *= self.n
                         dataOut.utctime = avgdatatime
                         # print avgdata, avgdatatime
                         # raise
                         #   dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                         dataOut.flagNoData = False
                     return dataOut
             class Decoder(Operation):
                 isConfig = False
                 __profIndex = 0
                 code = None
                 nCode = None
                 nBaud = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.times = None
                     self.osamp = None
                 #         self.__setValues = False
                     self.isConfig = False
                     self.setupReq = False
                 def setup(self, code, osamp, dataOut):
                     self.__profIndex = 0
                     self.code = code
                     self.nCode = len(code)
                     self.nBaud = len(code[0])
                     if (osamp != None) and (osamp >1):
                         self.osamp = osamp
                         self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
                         self.nBaud = self.nBaud*self.osamp
                     self.__nChannels = dataOut.nChannels
                     self.__nProfiles = dataOut.nProfiles
                     self.__nHeis = dataOut.nHeights
                     if self.__nHeis < self.nBaud:
                         raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
                     #Frequency
                     __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
                     __codeBuffer[:,0:self.nBaud] = self.code
                     self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                     if dataOut.flagDataAsBlock:
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
                     else:
                         #Time
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
                 def __convolutionInFreq(self, data):
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=1)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=1)
                     return data
                 def __convolutionInFreqOpt(self, data):
                     raise NotImplementedError
                 def __convolutionInTime(self, data):
                     code = self.code[self.__profIndex]
                     for i in range(self.__nChannels):
                         self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInTime(self, data):
                     repetitions = int(self.__nProfiles / self.nCode)
                     junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
                     junk = junk.flatten()
                     code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
                     profilesList = range(self.__nProfiles)
                     for i in range(self.__nChannels):
                         for j in profilesList:
                             self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInFreq(self, data):
                     raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=2)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=2)
                     return data
                 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
                     if dataOut.flagDecodeData:
                         print("This data is already decoded, recoding again ...")
                     if not self.isConfig:
                         if code is None:
                             if dataOut.code is None:
                                 raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
                             code = dataOut.code
                         else:
                             code = numpy.array(code).reshape(nCode,nBaud)
                         self.setup(code, osamp, dataOut)
                         self.isConfig = True
                         if mode == 3:
                             sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
                         if times != None:
                             sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
                     if self.code is None:
                         print("Fail decoding: Code is not defined.")
                         return
                     self.__nProfiles = dataOut.nProfiles
                     datadec = None
                     if mode == 3:
                         mode = 0
                     if dataOut.flagDataAsBlock:
                         """
                         Decoding when data have been read as block,
                         """
                         if mode == 0:
                             datadec = self.__convolutionByBlockInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionByBlockInFreq(dataOut.data)
                     else:
                         """
                         Decoding when data have been read profile by profile
                         """
                         if mode == 0:
                             datadec = self.__convolutionInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionInFreq(dataOut.data)
                         if mode == 2:
                             datadec = self.__convolutionInFreqOpt(dataOut.data)
                     if datadec is None:
                         raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
                     dataOut.code = self.code
                     dataOut.nCode = self.nCode
                     dataOut.nBaud = self.nBaud
                     dataOut.data = datadec
                     dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
                     dataOut.flagDecodeData = True #asumo q la data esta decodificada
                     if self.__profIndex == self.nCode-1:
                         self.__profIndex = 0
                         return dataOut
                     self.__profIndex += 1
                     return dataOut
                 #        dataOut.flagDeflipData = True #asumo q la data no esta sin flip
             class ProfileConcat(Operation):
                 isConfig = False
                 buffer = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def reset(self):
                     self.buffer = numpy.zeros_like(self.buffer)
                     self.start_index = 0
                     self.times = 1
                 def setup(self, data, m, n=1):
                     self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
                     self.nHeights = data.shape[1]#.nHeights
                     self.start_index = 0
                     self.times = 1
                 def concat(self, data):
                     self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
                     self.start_index = self.start_index + self.nHeights
                 def run(self, dataOut, m):
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(dataOut.data, m, 1)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
                     else:
                         self.concat(dataOut.data)
                         self.times += 1
                         if self.times > m:
                             dataOut.data = self.buffer
                             self.reset()
                             dataOut.flagNoData = False
                             # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
                             deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                             xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
                             dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
                             dataOut.ippSeconds *= m
                     return dataOut
             class ProfileSelector(Operation):
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def incProfileIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
                     if profileIndex < minIndex:
                         return False
                     if profileIndex > maxIndex:
                         return False
                     return True
                 def isThisProfileInList(self, profileIndex, profileList):
                     if profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
                     """
                     ProfileSelector:
                     Inputs:
                         profileList        :    Index of profiles selected. Example: profileList = (0,1,2,7,8)
                         profileRangeList    :    Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
                         rangeList            :    List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
                     """
                     if rangeList is not None:
                         if type(rangeList[0]) not in (tuple, list):
                             rangeList = [rangeList]
                     dataOut.flagNoData = True
                     if dataOut.flagDataAsBlock:
                         """
                         data dimension  = [nChannels, nProfiles, nHeis]
                         """
                         if profileList != None:
                             dataOut.data = dataOut.data[:,profileList,:]
                         if profileRangeList != None:
                             minIndex = profileRangeList[0]
                             maxIndex = profileRangeList[1]
                             profileList = list(range(minIndex, maxIndex+1))
                             dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
                         if rangeList != None:
                             profileList = []
                             for thisRange in rangeList:
                                 minIndex = thisRange[0]
                                 maxIndex = thisRange[1]
                                 profileList.extend(list(range(minIndex, maxIndex+1)))
                             dataOut.data = dataOut.data[:,profileList,:]
                         dataOut.nProfiles = len(profileList)
                         dataOut.profileIndex = dataOut.nProfiles - 1
                         dataOut.flagNoData = False
                         return dataOut
                     """
                     data dimension  = [nChannels, nHeis]
                     """
                     if profileList != None:
                         if self.isThisProfileInList(dataOut.profileIndex, profileList):
                             self.nProfiles = len(profileList)
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if profileRangeList != None:
                         minIndex = profileRangeList[0]
                         maxIndex = profileRangeList[1]
                         if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                             self.nProfiles = maxIndex - minIndex + 1
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if rangeList != None:
                         nProfiles = 0
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             nProfiles += maxIndex - minIndex + 1
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                                 self.nProfiles = nProfiles
                                 dataOut.nProfiles = self.nProfiles
                                 dataOut.profileIndex = self.profileIndex
                                 dataOut.flagNoData = False
                                 self.incProfileIndex()
                                 break
                         return dataOut
                     if beam != None: #beam is only for AMISR data
                         if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
                             dataOut.flagNoData = False
                             dataOut.profileIndex = self.profileIndex
                             self.incProfileIndex()
                         return dataOut
                     raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
                     #return False
                     return dataOut
             class Reshaper(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__buffer = None
                     self.__nitems = 0
                 def __appendProfile(self, dataOut, nTxs):
                     if self.__buffer is None:
                         shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
                         self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
                     ini = dataOut.nHeights * self.__nitems
                     end = ini + dataOut.nHeights
                     self.__buffer[:, ini:end] = dataOut.data
                     self.__nitems += 1
                     return int(self.__nitems*nTxs)
                 def __getBuffer(self):
                     if self.__nitems == int(1./self.__nTxs):
                         self.__nitems = 0
                         return self.__buffer.copy()
                     return None
                 def __checkInputs(self, dataOut, shape, nTxs):
                     if shape is None and nTxs is None:
                         raise ValueError("Reshaper: shape of factor should be defined")
                     if nTxs:
                         if nTxs < 0:
                             raise ValueError("nTxs should be greater than 0")
                         if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
                             raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
                         shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
                         return shape, nTxs
                     if len(shape) != 2 and len(shape) !=  3:
                         raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
                     if len(shape) == 2:
                         shape_tuple = [dataOut.nChannels]
                         shape_tuple.extend(shape)
                     else:
                         shape_tuple = list(shape)
                     nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
                     return shape_tuple, nTxs
                 def run(self, dataOut, shape=None, nTxs=None):
                     shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
                     else:
                         if self.__nTxs < 1:
                             self.__appendProfile(dataOut, self.__nTxs)
                             new_data = self.__getBuffer()
                             if new_data is not None:
                                 dataOut.data = new_data
                                 dataOut.flagNoData = False
                                 profileIndex = dataOut.profileIndex*nTxs
                         else:
                             raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= self.__nTxs
                     return dataOut
             class SplitProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         if shape[2] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
                         new_shape = shape[0], shape[1]*n, int(shape[2]/n)
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles/n) - 1
                     else:
                         raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= n
                     return dataOut
             class CombineProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__remData = None
                     self.__profileIndex = 0
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         new_shape = shape[0], shape[1]/n, shape[2]*n
                         if shape[1] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*n) - 1
                     else:
                         #nchannels, nsamples
                         if self.__remData is None:
                             newData = dataOut.data
                         else:
                             newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
                         self.__profileIndex += 1
                         if self.__profileIndex < n:
                             self.__remData = newData
                             #continue
                             return
                         self.__profileIndex = 0
                         self.__remData = None
                         dataOut.data = newData
                         dataOut.flagNoData = False
                         profileIndex = dataOut.profileIndex/n
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles/n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds *= n
                     return dataOut
             class CreateBlockVoltage(Operation):
                 isConfig       = False
                 __Index        = 0
                 bufferShape    = None
                 buffer         = None
                 firstdatatime  = None
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                     self.isConfig = False
                     self.__Index = 0
                     self.firstdatatime = None
                 def setup(self,dataOut, m = None ):
                     '''
                     m= Numero perfiles
                     '''
                     #print("CONFIGURANDO CBV")
                     self.__nChannels  = dataOut.nChannels
                     self.__nHeis      = dataOut.nHeights
                     shape             = dataOut.data.shape #nchannels, nprofiles, nsamples
                     #print("input nChannels",self.__nChannels)
                     #print("input nHeis",self.__nHeis)
                     #print("SETUP CREATE BLOCK VOLTAGE")
                     #print("input Shape",shape)
                     #print("dataOut.nProfiles",dataOut.nProfiles)
                     numberSamples     = self.__nHeis
                     numberProfile     = int(m)
                     dataOut.nProfiles = numberProfile
                     #print("new numberProfile",numberProfile)
                     #print("new numberSamples",numberSamples)
                     self.bufferShape  = shape[0], numberProfile, numberSamples  # nchannels,nprofiles,nsamples
-                    self.buffer       = numpy.zeros((self.bufferShape))
+                    self.buffer       = numpy.zeros([shape[0], numberProfile, numberSamples])
-                    self.bufferVel    = numpy.zeros((self.bufferShape))
+                    self.bufferVel    = numpy.zeros([shape[0], numberProfile, numberSamples])
                 def run(self, dataOut, m=None):
                     #print("RUN")
                     dataOut.flagNoData      = True
                     dataOut.flagDataAsBlock = False
                     #print("BLOCK INDEX        ",self.__Index)
                     if not self.isConfig:
                         self.setup(dataOut, m= m)
                         self.isConfig = True
                     if self.__Index < m:
                         #print("PROFINDEX BLOCK         CBV",self.__Index)
                         self.buffer[:,self.__Index,:]    = dataOut.data
+                        #corregir porque debe tener un perfil menos ojo
                         self.bufferVel[:,self.__Index,:] = dataOut.data_velocity
                         self.__Index += 1
                         dataOut.flagNoData =  True
                     if self.firstdatatime == None:
                         self.firstdatatime = dataOut.utctime
                     if self.__Index == m:
                         #print("**********************************************")
                         #print("self.buffer.shape           ",self.buffer.shape)
                         #print("##############",self.firstdatatime)
                         ##print("*********************************************")
                         ##print("*********************************************")
                         ##print("******* nProfiles *******", dataOut.nProfiles)
                         ##print("*********************************************")
                         ##print("*********************************************")
                         dataOut.data            = self.buffer
                         dataOut.data_velocity   = self.bufferVel
                         dataOut.utctime         = self.firstdatatime
                         dataOut.nProfiles       = m
                         self.firstdatatime      = None
                         dataOut.flagNoData      = False
                         dataOut.flagDataAsBlock = True
                         self.__Index            = 0
                         dataOut.identifierWR    = True
                     return dataOut
             class PulsePairVoltage(Operation):
                 '''
                 Function PulsePair(Signal Power, Velocity)
                 The real component of Lag[0] provides Intensity Information
                 The imag component of Lag[1] Phase provides Velocity Information
                 Configuration Parameters:
                 nPRF = Number of Several PRF
                 theta = Degree Azimuth angel Boundaries
                 Input:
                       self.dataOut
                       lag[N]
                 Affected:
                       self.dataOut.spc
                 '''
                 isConfig       = False
                 __profIndex    = 0
                 __initime      = None
                 __lastdatatime = None
                 __buffer       = None
                 __buffer2      = []
                 __buffer3      = None
                 __dataReady    = False
                 n              = None
                 __nch          = 0
                 __nHeis        = 0
+                removeDC       = False
+                ipp            = None
+                lambda_        = 0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
-                def setup(self, dataOut, n = None ):
+                def setup(self, dataOut, n = None, removeDC=False):
                     '''
                     n= Numero de PRF's de entrada
                     '''
                     self.__initime        = None
                     self.__lastdatatime   = 0
                     self.__dataReady      = False
                     self.__buffer         = 0
                     self.__buffer2        = []
                     self.__buffer3        = 0
                     self.__profIndex      = 0
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
+                    self.removeDC         = removeDC
+                    self.lambda_          = 3.0e8/(9345.0e6)
+                    self.ippSec           = dataOut.ippSeconds
+                    print("IPPseconds",dataOut.ippSeconds)
                     print("ELVALOR DE n es:", n)
                     if n == None:
                         raise ValueError("n should be specified.")
                     if n != None:
                         if n<2:
                             raise ValueError("n should be greater than 2")
                     self.n       = n
                     self.__nProf = n
-                    '''
-                    if overlapping:
-                        self.__withOverlapping = True
-                        self.__buffer          = None
-                    else:
+                    self.__buffer = numpy.zeros((dataOut.nChannels,
-                        #print ("estoy sin __withO")
+                                                       n,
-                        self.__withOverlapping = False
+                                                       dataOut.nHeights),
-                        self.__buffer          = 0
+                                                      dtype='complex')
-                        self.__buffer2         = []
-                        self.__buffer3         = 0
-                    '''
                 def putData(self,data):
                     '''
                     Add a profile to he __buffer and increase in one the __profiel Index
                     '''
-                    #print("self.__profIndex             :",self.__profIndex)
+                    self.__buffer[:,self.__profIndex,:]= data
-                    self.__buffer         += data*numpy.conjugate(data)
-                    self.__buffer2.append(numpy.conjugate(data))
-                    if self.__profIndex > 0:
-                        self.__buffer3    += self.__buffer2[self.__profIndex-1]*data
                     self.__profIndex      += 1
                     return
-                    '''
-                    if not self.__withOverlapping:
-                        #print("Putdata inside over")
-                        self.__buffer       += data* numpy.conjugate(data)
-                        self.__buffer2.append(numpy.conjugate(data))
-                        if self.__profIndex >0:
-                            self.__buffer3 += self.__buffer2[self.__profIndex-1]*data
-                        self.__profIndex   += 1
-                        return
-                    if self.__buffer is None:
-                        #print("aqui bro")
-                        self.__buffer     = data* numpy.conjugate(data)
-                        self.__buffer2.append(numpy.conjugate(data))
-                        self.__profIndex += 1
-                        return
-                    if self.__profIndex < self.n:
-                        self.__buffer = numpy.vstack(self.__buffer,data* numpy.conjugate(data))
-                        self.__buffer2.append(numpy.conjugate(data))
-                        if self.__profIndex == 1:
-                            self.__buffer3  =  self.__buffer2[self.__profIndex -1] * data
-                        else:
-                            self.__buffer3  = numpy.vstack(self.__buffer3, self.__buffer2[self.profIndex-1]*data)
-                        self.__profIndex += 1
-                        return
-                    '''
                 def pushData(self):
                     '''
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
-                    #print("************************************************")
-                    #print("push data int vel n")
+                    if self.removeDC==True:
-                    data_intensity   = self.__buffer/self.n
+                        mean    = numpy.mean(self.__buffer,1)
-                    data_velocity    = self.__buffer3/(self.n-1)
+                        tmp     = mean.reshape(self.__nch,1,self.__nHeis)
+                        dc= numpy.tile(tmp,[1,self.__nProf,1])
+                        self.__buffer = self.__buffer -  dc
+                    data_intensity   = numpy.sum(self.__buffer*numpy.conj(self.__buffer),1)/self.n
+                    pair1            = self.__buffer[:,1:,:]*numpy.conjugate(self.__buffer[:,:-1,:])
+                    angle=numpy.angle(numpy.sum(pair1,1))*180/(math.pi)
+                    #print(angle.shape)#print("__ANGLE__") #print("angle",angle[:,:10])
+                    data_velocity    = (self.lambda_/(4*math.pi*self.ippSec))*numpy.angle(numpy.sum(pair1,1))
                     n                = self.__profIndex
-                    self.__buffer    = 0
+                    self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
-                    self.__buffer2   = []
-                    self.__buffer3   = 0
                     self.__profIndex = 0
+                    return data_intensity,data_velocity,n
-                    return data_intensity, data_velocity,n
-                    '''
-                    if not self.__withOverlapping:
-                        #print("ahora que fue")
-                        data_intensity = self.__buffer/self.n
-                        data_velocity  = self.__buffer3/(self.n-1)
-                        n = self.__profIndex
-                        self.__buffer    = 0
-                        self.__buffer2   = []
-                        self.__buffer3   = 0
-                        self.__profIndex = 0
-                        return data_intensity, data_velocity,n
-                    data_intensity = numpy.sum(self.__buffer,axis  = 0)
-                    data_velocity  = numpy.sum(self.__buffer3,axis = 0)
-                    n              = self.__profIndex
-                    #self.__buffer    = 0
-                    #self.__buffer2   = []
-                    #self.__buffer3   = 0
-                    #self.__profIndex = 0
-                    return data_intensity, data_velocity,n
-                    '''
                 def pulsePairbyProfiles(self,data):
                     self.__dataReady     =  False
                     data_intensity       =  None
                     data_velocity        =  None
-                    #print("beforeputada")
                     self.putData(data)
-                    #print("ProfileIndex:",self.__profIndex)
                     if self.__profIndex  == self.n:
                         data_intensity, data_velocity, n   = self.pushData()
                         self.__dataReady                   = True
-                        #print("-----------------------------------------------")
-                        #print("data_intensity",data_intensity.shape,"data_velocity",data_velocity.shape)
                     return data_intensity, data_velocity
                 def pulsePairOp(self, data, datatime= None):
                     if self.__initime == None:
                         self.__initime = datatime
                     data_intensity, data_velocity = self.pulsePairbyProfiles(data)
                     self.__lastdatatime           = datatime
                     if data_intensity is None:
                         return None, None, None
                     avgdatatime    = self.__initime
                     deltatime      = datatime - self.__lastdatatime
                     self.__initime = datatime
-                    '''
-                    if not self.__withOverlapping:
-                        self.__initime = datatime
-                    else:
-                        self.__initime += deltatime
-                    '''
                     return data_intensity, data_velocity, avgdatatime
-                def run(self, dataOut,n = None, overlapping= False,**kwargs):
+                def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
                     if not self.isConfig:
-                        self.setup(dataOut = dataOut, n    = n , **kwargs)
+                        self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
                     #print("*******************")
                     #print("print Shape input data:",dataOut.data.shape)
                     data_intensity, data_velocity, avgdatatime = self.pulsePairOp(dataOut.data, dataOut.utctime)
                     dataOut.flagNoData                         = True
                     if self.__dataReady:
                         #print("#------------------------------------------------------")
                         #print("data_ready",data_intensity.shape)
                         dataOut.data            = data_intensity #valor para plotear RTI
                         dataOut.nCohInt        *= self.n
                         dataOut.data_intensity  = data_intensity #valor para intensidad
                         dataOut.data_velocity   = data_velocity  #valor para velocidad
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut
-            # import collections
-            # from scipy.stats import mode
-            # class Synchronize(Operation):
-            #     isConfig = False
-            #     __profIndex = 0
-            #     def __init__(self, **kwargs):
-            #         Operation.__init__(self, **kwargs)
-            # #         self.isConfig = False
-            #         self.__powBuffer = None
-            #         self.__startIndex = 0
-            #         self.__pulseFound = False
-            #     def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
-            #         #Read data
-            #         powerdB = dataOut.getPower(channel = channel)
-            #         noisedB = dataOut.getNoise(channel = channel)[0]
-            #         self.__powBuffer.extend(powerdB.flatten())
-            #         dataArray = numpy.array(self.__powBuffer)
-            #         filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
-            #         maxValue = numpy.nanmax(filteredPower)
-            #         if maxValue < noisedB + 10:
-            #             #No se encuentra ningun pulso de transmision
-            #             return None
-            #         maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
-            #         if len(maxValuesIndex) < 2:
-            #             #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
-            #             return None
-            #         phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
-            #         #Seleccionar solo valores con un espaciamiento de nSamples
-            #         pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
-            #         if len(pulseIndex) < 2:
-            #             #Solo se encontro un pulso de transmision con ancho mayor a 1
-            #             return None
-            #         spacing = pulseIndex[1:] - pulseIndex[:-1]
-            #         #remover senales que se distancien menos de 10 unidades o muestras
-            #         #(No deberian existir IPP menor a 10 unidades)
-            #         realIndex = numpy.where(spacing > 10 )[0]
-            #         if len(realIndex) < 2:
-            #             #Solo se encontro un pulso de transmision con ancho mayor a 1
-            #             return None
-            #         #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
-            #         realPulseIndex = pulseIndex[realIndex]
-            #         period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
-            #         print "IPP = %d samples" %period
-            #         self.__newNSamples = dataOut.nHeights #int(period)
-            #         self.__startIndex = int(realPulseIndex[0])
-            #         return 1
-            #     def setup(self, nSamples, nChannels, buffer_size = 4):
-            #         self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
-            #                                           maxlen = buffer_size*nSamples)
-            #         bufferList = []
-            #         for i in range(nChannels):
-            #             bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) +  numpy.NAN,
-            #                                           maxlen = buffer_size*nSamples)
-            #             bufferList.append(bufferByChannel)
-            #         self.__nSamples = nSamples
-            #         self.__nChannels = nChannels
-            #         self.__bufferList = bufferList
-            #     def run(self, dataOut, channel = 0):
-            #         if not self.isConfig:
-            #             nSamples = dataOut.nHeights
-            #             nChannels = dataOut.nChannels
-            #             self.setup(nSamples, nChannels)
-            #             self.isConfig = True
-            #         #Append new data to internal buffer
-            #         for thisChannel in range(self.__nChannels):
-            #             bufferByChannel = self.__bufferList[thisChannel]
-            #             bufferByChannel.extend(dataOut.data[thisChannel])
-            #         if self.__pulseFound:
-            #             self.__startIndex -= self.__nSamples
-            #         #Finding Tx Pulse
-            #         if not self.__pulseFound:
-            #             indexFound = self.__findTxPulse(dataOut, channel)
-            #             if indexFound == None:
-            #                 dataOut.flagNoData = True
-            #                 return
-            #             self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
-            #             self.__pulseFound = True
-            #             self.__startIndex = indexFound
-            #         #If pulse was found ...
-            #         for thisChannel in range(self.__nChannels):
-            #             bufferByChannel = self.__bufferList[thisChannel]
-            #             #print self.__startIndex
-            #             x = numpy.array(bufferByChannel)
-            #             self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
-            #         deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
-            #         dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
-            # #             dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
-            #         dataOut.data = self.__arrayBuffer
-            #         self.__startIndex += self.__newNSamples
-            #         return

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