schain-jc Commit - r1207:15feaa6e0b57

Fix SpectralMoments Plot

Juan C. Espinoza -

r1207:15feaa6e0b57

parent child

Context file:

r1207:15feaa6e0b57

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schainpy/model/data/jrodata.py +8 -3

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

schainpy/model/graphics/jroplot_data.py +8 -9

             '''
             New Plots Operations
             @author: juan.espinoza@jro.igp.gob.pe
             '''
             import time
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.utils import log
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jro'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width += 0.8 * self.ncols
                     self.ylabel = 'Range [km]'
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
-                    if self.CODE == 'spc_mean':
+                    if self.CODE == 'spc_moments':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     z = self.data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
-                        if self.CODE == 'spc_mean':
+                        if self.CODE == 'spc_moments':
-                            mean = self.data['mean'][n][-1]
+                            mean = self.data['moments'][n, :, 1, :][-1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
-                            if self.CODE == 'spc_mean':
+                            if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
-                            if self.CODE == 'spc_mean':
+                            if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     spc = self.data['spc']
                     cspc = self.data['cspc']
                     for n in range(self.nrows):
                         noise = self.data['noise'][n][-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
                         spc0 = 10.*numpy.log10(spc[pair[0]]/self.data.factor)
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
                             ax.plt = ax.pcolormesh(x , y , spc0.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc0.T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise))
                         ax = self.axes[4 * n + 1]
                         spc1 = 10.*numpy.log10(spc[pair[1]]/self.data.factor)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x , y, spc1.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc1.T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
-            class SpectraMeanPlot(SpectraPlot):
+            class SpectralMomentsPlot(SpectraPlot):
                 '''
-                Plot for Spectra and Mean
+                Plot for Spectral Moments
                 '''
-                CODE = 'spc_mean'
+                CODE = 'spc_moments'
                 colormap = 'jro'
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jro'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.cb_label = 'dB'
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.heights
                     self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     self.data['noise'][n][-1], len(self.y)), self.y)
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Noise']
                     self.colorbar = False
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data[self.CODE]
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 5
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class ParametersPlot(RTIPlot):
                 '''
                 Plot for data_param object
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     if self.showSNR:
                         self.nrows += 1
                         self.nplots += 1
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = self.data.parameters \
                             if self.data.parameters else ['Param {}'.format(x) for x in range(self.nrows)]
                         if self.showSNR:
                             self.titles.append('SNR')
                 def plot(self):
                     self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.heights
                     if self.showSNR:
                         self.z = numpy.concatenate(
                             (self.data[self.CODE], self.data['snr'])
                         )
                     else:
                         self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class OutputPlot(ParametersPlot):
                 '''
                 Plot data_output object
                 '''
                 CODE = 'output'
                 colormap = 'seismic'
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.heights)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.heights)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class ScopePlot(Plot):
                 '''
                    Plot for Scope
                 '''
                 CODE = 'scope'
                 def setup(self):
                     self.xaxis = 'Range (Km)'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Scope']
                     self.colorbar = False
                     colspan = 3
                     rowspan = 1
                 def plot_iq(self, x, y, channelIndexList, thisDatetime, wintitle):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity - IQ"
                     self.y = yreal
                     self.x = x
                     self.xmin = min(x)
                     self.xmax = max(x)
                     self.titles[0] = title
                     for i,ax in enumerate(self.axes):
                         title = "Channel %d" %(i)
                         if ax.firsttime:
                             ax.plt_r = ax.plot(x, yreal[i,:], color='b')[0]
                             ax.plt_i = ax.plot(x, yimag[i,:], color='r')[0]
                         else:
                             #pass
                             ax.plt_r.set_data(x, yreal[i,:])
                             ax.plt_i.set_data(x, yimag[i,:])
                 def plot_power(self, x, y, channelIndexList, thisDatetime, wintitle):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     self.y = yreal
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     self.xlabel = "Range (Km)"
                     self.ylabel = "Intensity"
                     self.xmin = min(x)
                     self.xmax = max(x)
                     self.titles[0] = title
                     for i,ax in enumerate(self.axes):
                         title = "Channel %d" %(i)
                         ychannel = yreal[i,:]
                         if ax.firsttime:
                             ax.plt_r = ax.plot(x, ychannel)[0]
                         else:
                             #pass
                             ax.plt_r.set_data(x, ychannel)
                 def plot(self):
                     if self.channels:
                         channels = self.channels
                     else:
                         channels = self.data.channels
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
                     scope = self.data['scope']
                     if self.data.flagDataAsBlock:
                         for i in range(self.data.nProfiles):
                             wintitle1 = " [Profile = %d] " %i
                             if self.type == "power":
                                 self.plot_power(self.data.heights,
                                                 scope[:,i,:],
                                                 channels,
                                                 thisDatetime,
                                                 wintitle1
                                                 )
                             if self.type == "iq":
                                 self.plot_iq(self.data.heights,
                                              scope[:,i,:],
                                              channels,
                                              thisDatetime,
                                              wintitle1
                                             )
                     else:
                         wintitle = " [Profile = %d] " %self.data.profileIndex
                         if self.type == "power":
                              self.plot_power(self.data.heights,
                                         scope,
                                         channels,
                                         thisDatetime,
                                         wintitle
                                         )
                         if self.type == "iq":
                             self.plot_iq(self.data.heights,
                                         scope,
                                         channels,
                                         thisDatetime,
                                         wintitle
                                         )
   No newline at end of file

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

             import os
             import datetime
             import numpy
             import inspect
             from .figure import Figure, isRealtime, isTimeInHourRange
             from .plotting_codes import *
             from schainpy.model.proc.jroproc_base import MPDecorator
             from schainpy.utils import log
             class ParamLine_(Figure):
                 isConfig = None
                 def __init__(self):
                     self.isConfig = False
                     self.WIDTH = 300
                     self.HEIGHT = 200
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     self.createFigure(id=id,
                                       wintitle=wintitle,
                                       show=show)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity - IQ"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
                         if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         axes.pline(x, yreal[i,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                         axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
                 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(yreal)
                         if ymax == None: ymax = numpy.nanmax(yreal)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, show=True, wr_period=1,
                         ftp=False, server=None, folder=None, username=None, password=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList" % channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     y = dataOut.RR
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = y[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                     self.draw()
                     str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") + "_" + str(dataOut.profileIndex)
                     figfile = self.getFilename(name = str_datetime)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class SpcParamPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'SpcParam'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None , Selector = 0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
-            #         if normFactor is None:
+             #         if normFactor is None:
-            #             factor = dataOut.normFactor
+             #             factor = dataOut.normFactor
-            #         else:
+             #         else:
-            #             factor = normFactor
+             #             factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.spcparam_range[0]
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.spcparam_range[1]
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.spcparam_range[2]
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.SPCparam[Selector] /1966080.0#/ dataOut.normFactor#GauSelector]    #dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.spc_noise
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class MomentsPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 280
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = MOMENTS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return None
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = dataOut.data_pre[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     avgdB = 10*numpy.log10(avg)
                     noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters"
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i], noisedB[i], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[i,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                                     #Mean Line
                         mean = dataOut.data_param[i, 1, :]
                         axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[i], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class SkyMapPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'mmap'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
-            #         self.WIDTH = 280
+             #         self.WIDTH = 280
-            #         self.HEIGHT = 250
+             #         self.HEIGHT = 250
                     self.WIDTH = 600
                     self.HEIGHT = 600
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = MSKYMAP_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH, #+ self.WIDTHPROF,
                                       heightplot = self.HEIGHT,# + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = 1,1
                     counter = 0
                     x = 0
                     y = 0
                     self.addAxes(1, 1, 0, 0, 1, 1, True)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         tmin=0, tmax=24, timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     arrayParameters = dataOut.data_param
                     error = arrayParameters[:,-1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid,:]
                     finalAzimuth = finalMeteor[:,3]
                     finalZenith = finalMeteor[:,4]
                     x = finalAzimuth*numpy.pi/180
                     y = finalZenith
                     x1 = [dataOut.ltctime, dataOut.ltctime]
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Parameters"
                     xlabel = "Zonal Zenith Angle (deg) "
                     ylabel = "Meridional Zenith Angle (deg)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if self.xmin is None and self.xmax is None:
                             self.xmin, self.xmax = self.getTimeLim(x1, tmin, tmax, timerange)
                         if timerange != None:
                             self.timerange = timerange
                         else:
                             self.timerange = self.xmax - self.xmin
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     i = 0
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     axes = self.axesList[i*self.__nsubplots]
                     nevents = axes.x_buffer.shape[0] + x.shape[0]
                     title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
                     axes.polar(x, y,
                                 title=title, xlabel=xlabel, ylabel=ylabel,
                                 ticksize=9, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime >= self.xmax:
                         self.isConfigmagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                         axes.__firsttime = True
                         self.xmin += self.timerange
                         self.xmax += self.timerange
             @MPDecorator
             class WindProfilerPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'wind'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = WIND_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
                         counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='False',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
                         timerange=None, SNRthresh = None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
-            #         if timerange is not None:
+             #         if timerange is not None:
-            #             self.timerange = timerange
+             #             self.timerange = timerange
+             #
-            #         tmin = None
+             #         tmin = None
-            #         tmax = None
+             #         tmax = None
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     z = dataOut.data_output.copy()
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR[0]
                         SNRavg = SNR#numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         if SNRthresh == None:
                             SNRthresh = -5.0
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     #thisDatetime = datetime.datetime.now()
                     title = wintitle + "Wind"
                     xlabel = ""
                     ylabel = "Height (km)"
                     update_figfile = False
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmax == None: zmax = numpy.nanmax(abs(z[list(range(2)),:]))
                         #if numpy.isnan(zmax): zmax = 50
                         if zmin == None: zmin = -zmax
                         if nplotsw == 3:
                             if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
                             if zmin_ver == None: zmin_ver = -zmax_ver
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal', 'Meridional', 'Vertical']
                     strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
                     zmaxVector = [zmax, zmax, zmax_ver]
                     zminVector = [zmin, zmin, zmin_ver]
                     windFactor = [1,1,100]
                     for i in range(nplotsw):
                         title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))*windFactor[i]
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="seismic" )
                     if dataOut.data_SNR is not None:
                         i += 1
                         title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.paramInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     return dataOut
             @MPDecorator
             class ParametersPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'param'
                 nplots = None
                 nchan = None
                 def __init__(self):#, **kwargs):
                     Figure.__init__(self)#, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 300
                     self.HEIGHT = 550
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, paramIndex = 0, colormap="jet",
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, timerange=None,
                         showSNR=False, SNRthresh = -numpy.inf, SNRmin=None, SNRmax=None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if HEIGHT is not None:
                         self.HEIGHT = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = list(range(dataOut.data_param.shape[0]))
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.getHeiRange()
                     if dataOut.data_param.ndim == 3:
                         z = dataOut.data_param[channelIndexList,paramIndex,:]
                     else:
                         z = dataOut.data_param[channelIndexList,:]
                     if showSNR:
                         #SNR data
                         SNRarray = dataOut.data_SNR[channelIndexList,:]
                         SNRdB = 10*numpy.log10(SNRarray)
                         ind = numpy.where(SNRdB < SNRthresh)
                         z[ind] = numpy.nan
                     thisDatetime = dataOut.datatime
-            #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
+             #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (km)"
                     update_figfile = False
                     if not self.isConfig:
                         nchan = len(channelIndexList)
                         self.nchan = nchan
                         self.plotFact = 1
                         nplots = nchan
                         if showSNR:
                             nplots = nchan*2
                             self.plotFact = 2
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
-            #         for i in range(self.nchan):
+                #         for i in range(self.nchan):
-            #             index = channelIndexList[i]
+                #             index = channelIndexList[i]
-            #             title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
+                #             title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
-            #             axes = self.axesList[i*self.plotFact]
+                #             axes = self.axesList[i*self.plotFact]
-            #             z1 = z[i,:].reshape((1,-1))
+                #             z1 = z[i,:].reshape((1,-1))
-            #             axes.pcolorbuffer(x, y, z1,
+                #             axes.pcolorbuffer(x, y, z1,
-            #                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
+                #                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
-            #                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
+                #                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
-            #                         ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
+                #                         ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
+                #
-            #             if showSNR:
+                #             if showSNR:
-            #                 title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
+                #                 title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
-            #                 axes = self.axesList[i*self.plotFact + 1]
+                #                 axes = self.axesList[i*self.plotFact + 1]
-            #                 SNRdB1 = SNRdB[i,:].reshape((1,-1))
+                #                 SNRdB1 = SNRdB[i,:].reshape((1,-1))
-            #                 axes.pcolorbuffer(x, y, SNRdB1,
+                #                 axes.pcolorbuffer(x, y, SNRdB1,
-            #                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
+                #                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
-            #                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
+                #                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
-            #                         ticksize=9, cblabel='', cbsize="1%",colormap='jet')
+             #                         ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     i=0
                     index = channelIndexList[i]
                     title = "Factor de reflectividad Z [dBZ]"
                     axes = self.axesList[i*self.plotFact]
                     z1 = z[i,:].reshape((1,-1))
                     axes.pcolorbuffer(x, y, z1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
                     if showSNR:
                         title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.plotFact + 1]
                         SNRdB1 = SNRdB[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRdB1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     i=1
                     index = channelIndexList[i]
                     title = "Velocidad vertical Doppler [m/s]"
                     axes = self.axesList[i*self.plotFact]
                     z1 = z[i,:].reshape((1,-1))
                     axes.pcolorbuffer(x, y, z1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=-10, zmax=10,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap='seismic_r')
                     if showSNR:
                         title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.plotFact + 1]
                         SNRdB1 = SNRdB[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRdB1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     i=2
                     index = channelIndexList[i]
                     title = "Intensidad de lluvia [mm/h]"
                     axes = self.axesList[i*self.plotFact]
                     z1 = z[i,:].reshape((1,-1))
                     axes.pcolorbuffer(x, y, z1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=0, zmax=40,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap='ocean_r')
                     if showSNR:
                         title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.plotFact + 1]
                         SNRdB1 = SNRdB[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRdB1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                 ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
             class Parameters1Plot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = PARMS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,timerange=None,
                         parameterIndex = None, onlyPositive = False,
                         SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None, onlySNR = False,
                         DOP = True,
                         zlabel = "", parameterName = "", parameterObject = "data_param",
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     data_param = getattr(dataOut, parameterObject)
                     if channelList == None:
                         channelIndexList = numpy.arange(data_param.shape[0])
                     else:
                         channelIndexList = numpy.array(channelList)
                     nchan = len(channelIndexList) #Number of channels being plotted
                     if nchan < 1:
                         return
                     nGraphsByChannel = 0
                     if SNR:
                         nGraphsByChannel += 1
                     if DOP:
                         nGraphsByChannel += 1
                     if nGraphsByChannel < 1:
                         return
                     nplots = nGraphsByChannel*nchan
                     if timerange is not None:
                         self.timerange = timerange
                     #tmin = None
                     #tmax = None
                     if parameterIndex == None:
                         parameterIndex = 1
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     if dataOut.data_param.ndim == 3:
                         z = dataOut.data_param[channelIndexList,parameterIndex,:]
                     else:
                         z = dataOut.data_param[channelIndexList,:]
                     if dataOut.data_SNR is not None:
                         if dataOut.data_SNR.ndim == 2:
                             SNRavg = numpy.average(dataOut.data_SNR, axis=0)
                         else:
                             SNRavg = dataOut.data_SNR
                         SNRdB = 10*numpy.log10(SNRavg)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if onlyPositive:
                         colormap = "jet"
                         zmin = 0
                     else: colormap = "RdBu_r"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         if SNR:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     for i in range(nchan):
                         if (SNR and not onlySNR): j = 2*i
                         else: j = i
                         j = nGraphsByChannel*i
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         if not onlySNR:
                             axes = self.axesList[j*self.__nsubplots]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                     ticksize=9, cblabel=zlabel, cbsize="1%")
                         if DOP:
                             title = "%s Channel %d: %s" %(parameterName, channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                                 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                             axes = self.axesList[j]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                         ticksize=9, cblabel=zlabel, cbsize="1%")
                     if SNR:
                         title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[(j)*self.__nsubplots]
                         if not onlySNR:
                             axes = self.axesList[(j + 1)*self.__nsubplots]
                         axes = self.axesList[(j + nGraphsByChannel-1)]
                         z1 = SNRdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
                                 ticksize=9, cblabel=zlabel, cbsize="1%")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=False)
                     return dataOut
             class SpectralFittingPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 N = None
                 ippSeconds = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = SPECFIT_CODE
                     self.WIDTH = 450
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 5
                     colspan = 4
                     if showprofile:
                         ncolspan = 5
                         colspan = 4
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if cutHeight==None:
                         h=270
                     heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
                     cutHeight = dataOut.heightList[heightindex]
                     factor = dataOut.normFactor
                     x = dataOut.abscissaList[:-1]
                     #y = dataOut.getHeiRange()
                     z = dataOut.data_pre[:,:,heightindex]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     listChannels = z.shape[0]
                     #Reconstruct Function
                     if fit==True:
                         groupArray = dataOut.groupList
                         listChannels = groupArray.reshape((groupArray.size))
                         listChannels.sort()
                         spcFitLine = numpy.zeros(z.shape)
                         constants = dataOut.constants
                         nGroups = groupArray.shape[0]
                         nChannels = groupArray.shape[1]
                         nProfiles = z.shape[1]
                         for f in range(nGroups):
                             groupChann = groupArray[f,:]
                             p = dataOut.data_param[f,:,heightindex]
-            #                 p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
+             #                 p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
                             fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
                             fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
                             spcFitLine[groupChann,:] = fitLineAux
-            #             spcFitLine = spcFitLine/factor
+             #             spcFitLine = spcFitLine/factor
                         z = z[listChannels,:]
                         spcFitLine = spcFitLine[listChannels,:]
                         spcFitLinedB = 10*numpy.log10(spcFitLine)
                     zdB = 10*numpy.log10(z)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Spectrum"
                     if not self.isConfig:
                         nplots = listChannels.size
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)+2
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
-            #             title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
+             #             title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
                         title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i])
                         axes = self.axesList[i*self.__nsubplots]
                         if fit == False:
                             axes.pline(x, zdB[i,:],
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title
                                         )
                         if fit == True:
                             fitline=spcFitLinedB[i,:]
                             y=numpy.vstack([zdB[i,:],fitline] )
                             legendlabels=['Data','Fitting']
                             axes.pmultilineyaxis(x, y,
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title,
                                         legendlabels=legendlabels, marker=None,
                                         linestyle='solid', grid='both')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class EWDriftsPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'drift'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 150
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = EWDRIFT_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
                         counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
                         timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if timerange is not None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
-            #         y = dataOut.heightList
+             #         y = dataOut.heightList
                     y = dataOut.heightList
                     z = dataOut.data_output
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR
                         if SNR_1:
                             SNR += 1
                         SNRavg = numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     showprofile = False
-            #        thisDatetime = dataOut.datatime
+             #        thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
                     title = wintitle + " EW Drifts"
                     xlabel = ""
                     ylabel = "Height (Km)"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
                         if zminZonal == None: zminZonal = -zmaxZonal
                         if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
                         if zminVertical == None: zminVertical = -zmaxVertical
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal','Vertical']
                     strCb = 'Velocity (m/s)'
                     zmaxVector = [zmaxZonal, zmaxVertical]
                     zminVector = [zminZonal, zminVertical]
                     for i in range(nplotsw):
                         title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
                     if dataOut.data_SNR is not None:
                         i += 1
                         if SNR_1:
                             title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         else:
                             title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
             class PhasePlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'mphase'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 600
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = MPHASE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
                     y = dataOut.getHeiRange()
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase"
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = dataOut.data_output
                     update_figfile = False
                     if not self.isConfig:
                         self.nplots = phase_beacon.size
                         self.setup(id=id,
                                    nplots=self.nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
                         if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         update_figfile = True
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Offset %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["phase %d"%(chan) for chan in numpy.arange(self.nplots)]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     self.save(figpath=figpath,
                       figfile=figfile,
                       save=save,
                       ftp=ftp,
                       wr_period=wr_period,
                       thisDatetime=thisDatetime,
                       update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.outputInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
             class NSMeteorDetection1Plot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #SEPARAR EN DOS PLOTS
                     nParam = dataOut.data_param.shape[1] - 3
                     utctime = dataOut.data_param[0,0]
                     tmet = dataOut.data_param[:,1].astype(int)
                     hmet = dataOut.data_param[:,2].astype(int)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.zeros((nParam, y.size, x.size - 1))
                     z[:,:] = numpy.nan
                     z[:,hmet,tmet] = dataOut.data_param[:,3:].T
                     z[0,:,:] = 10*numpy.log10(z[0,:,:])
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         pairsList = dataOut.groupList
                         self.nPairs = len(dataOut.groupList)
                         zminList = [SNRmin, vmin, cmin] + [pmin]*self.nPairs
                         zmaxList = [SNRmax, vmax, cmax] + [pmax]*self.nPairs
                         titleList = ["SNR","Radial Velocity","Coherence"]
                         cmapList = ["jet","RdBu_r","jet"]
                         for i in range(self.nPairs):
                             strAux1 = "Phase Difference "+ str(pairsList[i][0]) + str(pairsList[i][1])
                             titleList = titleList + [strAux1]
                             cmapList = cmapList + ["RdBu_r"]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(nParam):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
             class NSMeteorDetection2Plot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #Rebuild matrix
                     utctime = dataOut.data_param[0,0]
                     cmet = dataOut.data_param[:,1].astype(int)
                     tmet = dataOut.data_param[:,2].astype(int)
                     hmet = dataOut.data_param[:,3].astype(int)
                     nParam = 3
                     nChan = len(dataOut.groupList)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.full((nChan, nParam, y.size, x.size - 1),numpy.nan)
                     z[cmet,:,hmet,tmet] = dataOut.data_param[:,4:]
                     z[:,0,:,:] = 10*numpy.log10(z[:,0,:,:]) #logarithmic scale
                     z = numpy.reshape(z, (nChan*nParam, y.size, x.size-1))
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam*nChan
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         self.nChannels = nChan
                         zminList = []
                         zmaxList = []
                         titleList = []
                         cmapList = []
                         for i in range(self.nChannels):
                             strAux1 = "SNR Channel "+ str(i)
                             strAux2 = "Radial Velocity Channel "+ str(i)
                             strAux3 = "Spectral Width Channel "+ str(i)
                             titleList = titleList + [strAux1,strAux2,strAux3]
                             cmapList = cmapList + ["jet","RdBu_r","jet"]
                             zminList = zminList + [SNRmin,vmin,wmin]
                             zmaxList = zmaxList + [SNRmax,vmax,wmax]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(self.nplots):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
   No newline at end of file

schainpy/model/graphics/jroplot_spectra.py +5 -4

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from .figure import Figure, isRealtime, isTimeInHourRange
             from .plotting_codes import *
             from schainpy.model.proc.jroproc_base import MPDecorator
             from schainpy.utils import log
             @MPDecorator
             class SpectraPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                     self.indice=1
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.getNoise()/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
             class CrossSpectraPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 4
                     self.counter_imagwr = 0
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                     self.PLOT_CODE = CROSS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.indice=0
                 def getSubplots(self):
                     ncol = 4
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", pairsList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         coh_min=None, coh_max=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None,
                         xaxis='frequency'):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %str(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if not pairsIndexList:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     noisedB = 10*numpy.log10(noise)
                     if coh_min == None:
                         coh_min = 0.0
                     if coh_max == None:
                         coh_max = 1.0
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
-            #         xlabel = "Velocity (m/s)"
+             #         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=False,
                                    show=show)
                         avg = numpy.abs(numpy.average(z, axis=1))
                         avgdB = 10*numpy.log10(avg)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         chan_index0 = dataOut.channelList.index(pair[0])
                         chan_index1 = dataOut.channelList.index(pair[1])
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[chan_index0], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index0,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[chan_index1], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index1,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]  /  numpy.sqrt(  dataOut.data_spc[chan_index0,:,:]*dataOut.data_spc[chan_index1,:,:]  )
                         coherence = numpy.abs(coherenceComplex)
-            #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
+             #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
                         title = "Coherence Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+2]
                         axes0.pcolor(x, y, coherence,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=coh_min, zmax=coh_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, cblabel='')
                         title = "Phase Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+3]
                         axes0.pcolor(x, y, phase,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=phase_cmap, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
             class RTIPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, colormap='jet',
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     #colormap = kwargs.get('colormap', 'jet')
                     if HEIGHT is not None:
                         self.HEIGHT  = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     #factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
                     # avgdB = dataOut.getPower()
                     thisDatetime = dataOut.datatime
                     #thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if self.xmax is not None and dataOut.ltctime >= self.xmax: #yong
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         noise = dataOut.noise/factor
                         noisedB = 10*numpy.log10(noise)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         axes = self.axesList[i*self.__nsubplots]
                         zdB = avgdB[index].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
             class CoherenceMap_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = COH_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.counter_imagwr = 0
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0.
                         if zmax == None: zmax = 1.
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         coherence = numpy.abs(avgcoherenceComplex)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(coherence, y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         z = phase.reshape((1,-1))
                         title = "Phase Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2 + counter]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(phase, y,
                                     xmin=phase_min, xmax=phase_max, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
             class PowerProfilePlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 300
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None):
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     #for voltage
                     if dataOut.type == 'Voltage':
                         x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                         x = x.real
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     #for spectra
                     if dataOut.type == 'Spectra':
                         x = dataOut.data_spc[channelIndexList,:,:]/factor
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                         x = numpy.average(x, axis=1)
                     xdB = 10*numpy.log10(x)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(xdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(xdB)*1.1
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["channel %d"%x for x in channelList]
                     axes.pmultiline(xdB, y,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
             class SpectraCutPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc_cut'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 700
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None,
                         xaxis="frequency"):
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     hei_index = numpy.arange(25)*3 + 20
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange()/1000.
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Frequency (kHz)"
                         ylabel = "Power (dB)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange()
                         zdB = z[0,:,hei_index]
                         xlabel = "Time (ms)"
                         ylabel = "ACF"
                     else:
                         x = dataOut.getVelRange()
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Velocity (m/s)"
                         ylabel = "Power (dB)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Range Cuts %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)*0.9
                         if xmax == None: xmax = numpy.nanmax(x)*1.1
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Spectra Cuts: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["Range = %dKm" %y[i] for i in hei_index]
                     axes.pmultilineyaxis( x, zdB,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
             class Noise_(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'noise'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = NOISE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def openfile(self, filename):
                     dirname = os.path.dirname(filename)
                     if not os.path.exists(dirname):
                         os.mkdir(dirname)
                     f = open(filename,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
                     f.write('DD MM YYYY  HH MM SS   Channel0    Channel1    Channel2    Channel3\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     data_msg = ''
                     for i in range(len(data)):
                         data_msg += str(data[i]) + '  '
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   ' + data_msg + '\n')
                     f.close()
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     noise = dataOut.noise[channelIndexList]/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Intensity (dB)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
                         if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         noise_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_noise = os.path.join(figpath,noise_file)
                     self.setWinTitle(title)
                     title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["channel %d"%(idchannel) for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = noisedB.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     #store data beacon phase
                     if save:
                         self.save_data(self.filename_noise, noisedB, thisDatetime)
                     return dataOut
             @MPDecorator
             class BeaconPhase_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
-            #         if len(pairsIndexList) > 4:
+             #         if len(pairsIndexList) > 4:
-            #             pairsIndexList = pairsIndexList[0:4]
+             #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut

schainpy/model/graphics/mpldriver.py +1 -31

             import os
             import sys
             import datetime
             import numpy
-            import matplotlib
+            from .jroplot_base import matplotlib, make_axes_locatable, FuncFormatter, LinearLocator
-            if 'BACKEND' in os.environ:
-                matplotlib.use(os.environ['BACKEND'])
-            elif 'linux' in sys.platform:
-                matplotlib.use("TkAgg")
-            elif 'darwin' in sys.platform:
-                matplotlib.use('TkAgg')
-            else:
-                from schainpy.utils import log
-                log.warning('Using default Backend="Agg"', 'INFO')
-                matplotlib.use('Agg')
-            # Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
-            import matplotlib.pyplot
-            from mpl_toolkits.axes_grid1 import make_axes_locatable
-            from matplotlib.ticker import FuncFormatter, LinearLocator
-            ###########################################
-            # Actualizacion de las funciones del driver
-            ###########################################
-            # create jro colormap
-            jet_values = matplotlib.pyplot.get_cmap("jet", 100)(numpy.arange(100))[10:90]
-            blu_values = matplotlib.pyplot.get_cmap(
-                "seismic_r", 20)(numpy.arange(20))[10:15]
-            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
-                "jro", numpy.vstack((blu_values, jet_values)))
-            matplotlib.pyplot.register_cmap(cmap=ncmap)
             def createFigure(id, wintitle, width, height, facecolor="w", show=True, dpi=80):
                 matplotlib.pyplot.ioff()
                 fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor, figsize=(
 .0 * width / dpi, 1.0 * height / dpi))
                 fig.canvas.manager.set_window_title(wintitle)
             #     fig.canvas.manager.resize(width, height)
                 matplotlib.pyplot.ion()
                 if show:
                     matplotlib.pyplot.show()
                 return fig
             def closeFigure(show=False, fig=None):
                 #     matplotlib.pyplot.ioff()
                 #     matplotlib.pyplot.pause(0)
                 if show:
                     matplotlib.pyplot.show()
                 if fig != None:
                     matplotlib.pyplot.close(fig)
             #         matplotlib.pyplot.pause(0)
             #         matplotlib.pyplot.ion()
                     return
                 matplotlib.pyplot.close("all")
             #     matplotlib.pyplot.pause(0)
             #     matplotlib.pyplot.ion()
                 return
             def saveFigure(fig, filename):
                 #     matplotlib.pyplot.ioff()
                 fig.savefig(filename, dpi=matplotlib.pyplot.gcf().dpi)
             #     matplotlib.pyplot.ion()
             def clearFigure(fig):
                 fig.clf()
             def setWinTitle(fig, title):
                 fig.canvas.manager.set_window_title(title)
             def setTitle(fig, title):
                 fig.suptitle(title)
             def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan, polar=False):
                 matplotlib.pyplot.ioff()
                 matplotlib.pyplot.figure(fig.number)
                 axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
                                                       (xpos, ypos),
                                                       colspan=colspan,
                                                       rowspan=rowspan,
                                                       polar=polar)
                 matplotlib.pyplot.ion()
                 return axes
             def setAxesText(ax, text):
                 ax.annotate(text,
                             xy=(.1, .99),
                             xycoords='figure fraction',
                             horizontalalignment='left',
                             verticalalignment='top',
                             fontsize=10)
             def printLabels(ax, xlabel, ylabel, title):
                 ax.set_xlabel(xlabel, size=11)
                 ax.set_ylabel(ylabel, size=11)
                 ax.set_title(title, size=8)
             def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                             ticksize=9, xtick_visible=True, ytick_visible=True,
                             nxticks=4, nyticks=10,
                             grid=None, color='blue'):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 ######################################################
                 if (xmax - xmin) <= 1:
                     xtickspos = numpy.linspace(xmin, xmax, nxticks)
                     xtickspos = numpy.array([float("%.1f" % i) for i in xtickspos])
                     ax.set_xticks(xtickspos)
                 else:
                     xtickspos = numpy.arange(nxticks) * \
                         int((xmax - xmin) / (nxticks)) + int(xmin)
             #         xtickspos = numpy.arange(nxticks)*float(xmax-xmin)/float(nxticks) + int(xmin)
                     ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ######################################################
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 ax.plot(x, y, color=color)
                 iplot = ax.lines[-1]
                 ######################################################
                 if '0.' in matplotlib.__version__[0:2]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def set_linedata(ax, x, y, idline):
                 ax.lines[idline].set_data(x, y)
             def pline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def addpline(ax, x, y, color, linestyle, lw):
                 ax.plot(x, y, color=color, linestyle=linestyle, lw=lw)
             def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
                              xlabel='', ylabel='', title='', ticksize=9,
                              colormap='jet', cblabel='', cbsize="5%",
                              XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 divider = make_axes_locatable(ax)
                 ax_cb = divider.new_horizontal(size=cbsize, pad=0.05)
                 fig = ax.get_figure()
                 fig.add_axes(ax_cb)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 z = numpy.ma.masked_invalid(z)
                 cmap = matplotlib.pyplot.get_cmap(colormap)
                 cmap.set_bad('white', 1.)
                 imesh = ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
                 cb = matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
                 cb.set_label(cblabel)
             #    for tl in ax_cb.get_yticklabels():
             #        tl.set_visible(True)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in cb.ax.get_yticklabels():
                     tick.set_fontsize(ticksize)
                 ax_cb.yaxis.tick_right()
                 if '0.' in matplotlib.__version__[0:2]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return imesh
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return imesh
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     def func(x, pos): return ('%s') % (
                         datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 matplotlib.pyplot.ion()
                 return imesh
             def pcolor(imesh, z, xlabel='', ylabel='', title=''):
                 z = z.T
                 ax = imesh.axes
                 printLabels(ax, xlabel, ylabel, title)
                 imesh.set_array(z.ravel())
             def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax,
                               cmap=matplotlib.pyplot.get_cmap(colormap))
             def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
                 printLabels(ax, xlabel, ylabel, title)
                 ax.collections.remove(ax.collections[0])
                 z = numpy.ma.masked_invalid(z)
                 cmap = matplotlib.pyplot.get_cmap(colormap)
                 cmap.set_bad('white', 1.)
                 ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
             def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                                  ticksize=9, xtick_visible=True, ytick_visible=True,
                                  nxticks=4, nyticks=10,
                                  grid=None):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
                 lines = ax.plot(x.T, y)
                 leg = ax.legend(lines, legendlabels, loc='upper right')
                 leg.get_frame().set_alpha(0.5)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
                 xtickspos = numpy.arange(nxticks) * \
                     int((xmax - xmin) / (nxticks)) + int(xmin)
                 ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x[i, :], y)
             def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
                                       ticksize=9, xtick_visible=True, ytick_visible=True,
                                       nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
                                       grid=None, XAxisAsTime=False):
                 """
                 Input:
                     grid    :    None, 'both', 'x', 'y'
                 """
                 matplotlib.pyplot.ioff()
             #    lines = ax.plot(x, y.T, marker=marker,markersize=markersize,linestyle=linestyle)
                 lines = ax.plot(x, y.T)
             #     leg = ax.legend(lines, legendlabels, loc=2, bbox_to_anchor=(1.01, 1.00), numpoints=1, handlelength=1.5, \
             #                     handletextpad=0.5, borderpad=0.5, labelspacing=0.5, borderaxespad=0.)
                 leg = ax.legend(lines, legendlabels,
                                 loc='upper right', bbox_to_anchor=(1.16, 1), borderaxespad=0)
                 for label in leg.get_texts():
                     label.set_fontsize(9)
                 ax.set_xlim([xmin, xmax])
                 ax.set_ylim([ymin, ymax])
                 printLabels(ax, xlabel, ylabel, title)
             #    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
             #    ax.set_xticks(xtickspos)
                 for tick in ax.get_xticklabels():
                     tick.set_visible(xtick_visible)
                 for tick in ax.xaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 for tick in ax.get_yticklabels():
                     tick.set_visible(ytick_visible)
                 for tick in ax.yaxis.get_major_ticks():
                     tick.label.set_fontsize(ticksize)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if grid != None:
                     ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 if XAxisAsTime:
                     def func(x, pos): return ('%s') % (
                         datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
                     ax.xaxis.set_major_formatter(FuncFormatter(func))
                     ax.xaxis.set_major_locator(LinearLocator(7))
                 matplotlib.pyplot.ion()
                 return iplot
             def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.axes
                 printLabels(ax, xlabel, ylabel, title)
                 for i in range(len(ax.lines)):
                     line = ax.lines[i]
                     line.set_data(x, y[i, :])
             def createPolar(ax, x, y,
                             xlabel='', ylabel='', title='', ticksize=9,
                             colormap='jet', cblabel='', cbsize="5%",
                             XAxisAsTime=False):
                 matplotlib.pyplot.ioff()
                 ax.plot(x, y, 'bo', markersize=5)
             #     ax.set_rmax(90)
                 ax.set_ylim(0, 90)
                 ax.set_yticks(numpy.arange(0, 90, 20))
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center' ,size='11')
             #     ax.text(0, 50, ylabel, rotation='vertical', va ='center', ha = 'left' ,size='11')
             #     ax.text(100, 100, 'example', ha='left', va='center', rotation='vertical')
                 ax.yaxis.labelpad = 40
                 printLabels(ax, xlabel, ylabel, title)
                 iplot = ax.lines[-1]
                 if '0.' in matplotlib.__version__[0:2]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
                 if '1.0.' in matplotlib.__version__[0:4]:
                     print("The matplotlib version has to be updated to 1.1 or newer")
                     return iplot
             #     if grid != None:
             #         ax.grid(b=True, which='major', axis=grid)
                 matplotlib.pyplot.tight_layout()
                 matplotlib.pyplot.ion()
                 return iplot
             def polar(iplot, x, y, xlabel='', ylabel='', title=''):
                 ax = iplot.axes
             #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center',size='11')
                 printLabels(ax, xlabel, ylabel, title)
                 set_linedata(ax, x, y, idline=0)
             def draw(fig):
                 if type(fig) == 'int':
                     raise ValueError("Error drawing: Fig parameter should be a matplotlib figure object figure")
                 fig.canvas.draw()
             def pause(interval=0.000001):
                 matplotlib.pyplot.pause(interval)

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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