schain Commit - r1062:8048843f4edf · Jicamarca Repository

Fix publish and plots operations issue #929

Juan C. Espinoza -

r1062:8048843f4edf

parent child

Context file:

r1062:8048843f4edf

Collapse all files

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

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

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

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

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

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

schainpy/model/proc/jroproc_spectra.py +17 -18

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

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

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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