schain Commit - r1782:c73c874ee2f8 · Jicamarca Repository

Tested window 20

Christianpl -

r1782:c73c874ee2f8

parent child

Context file:

r1782:c73c874ee2f8

Collapse all files

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

schainpy/model/data/jrodata.py +5 -4

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Definition of diferent Data objects for different types of data
             Here you will find the diferent data objects for the different types
             of data, this data objects must be used as dataIn or dataOut objects in
             processing units and operations. Currently the supported data objects are:
             Voltage, Spectra, SpectraHeis, Fits, Correlation and Parameters
             """
             import copy
             import numpy
             import datetime
             import json
             import schainpy.admin
             from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader
             from schainpy.model.data import _noise
             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)
                 #print(numpy.shape(data))
                 #exit()
-                '''
                 lenOfData = len(sortdata)
                 nums_min = lenOfData*0.2
                 if nums_min <= 5:
                     nums_min = 5
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont == 1)and(j < lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
                             sump = sump - sortdata[j]
                             sumq = sumq - sortdata[j]**2
                             cont = 0
                     j += 1
                 lnoise = sump / j
                 return lnoise
-                '''
-                return _noise.hildebrand_sekhon(sortdata, navg)
+                #return _noise.hildebrand_sekhon(sortdata, navg)
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 blockReader = False
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in list(inputObj.__dict__.keys()):
                         attribute = inputObj.__dict__[key]
                         # If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         # If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
                 def isReady(self):
                     return not self.flagNoData
             class JROData(GenericData):
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 type = None
                 datatype = None  # dtype but in string
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
                 nCohInt = None
                 windowOfFilter = 1
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 error = None
                 data = None
                 nmodes = None
                 metadata_list = ['heightList', 'timeZone', 'type']
                 def __str__(self):
                     try:
                         dt = self.datatime
                     except:
                         dt = 'None'
                     return '{} - {}'.format(self.type, dt)
                 def getNoise(self):
                     raise NotImplementedError
                 @property
                 def nChannels(self):
                     return len(self.channelList)
                 @property
                 def channelIndexList(self):
                     return list(range(self.nChannels))
                 @property
                 def nHeights(self):
                     return len(self.heightList)
                 def getDeltaH(self):
                     return self.heightList[1] - self.heightList[0]
                 @property
                 def ltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 @property
                 def datatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval + 1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     #print("ippsec",self.ippSeconds)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C / self.frequency
                     vmax = self.getFmax() * _lambda / 2
                     return vmax
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 @ippSeconds.setter
                 def ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                 @property
                 def code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 @code.setter
                 def code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                 @property
                 def nCode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 @nCode.setter
                 def nCode(self, ncode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = ncode
                 @property
                 def nBaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 @nBaud.setter
                 def nBaud(self, nbaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nbaud
                 @property
                 def ipp(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ipp
                 @ipp.setter
                 def ipp(self, ipp):
                     '''
                     '''
                     self.radarControllerHeaderObj.ipp = ipp
                 @property
                 def metadata(self):
                     '''
                     '''
                     return {attr: getattr(self, attr) for attr in self.metadata_list}
             class Voltage(JROData):
                 dataPP_POW   = None
                 dataPP_DOP   = None
                 dataPP_WIDTH = None
                 dataPP_SNR   = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagCohInt = False
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'nProfiles', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp']
                 def getNoisebyHildebrand(self, channel=None, Profmin_index=None, Profmax_index=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:
                             #print(power.shape)
                             daux = power[thisChannel, Profmin_index:Profmax_index, :].real
                             #print(daux.shape)
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type=1, channel=None, Profmin_index=None, Profmax_index=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel, Profmin_index, Profmax_index)
                     return noise
                 def getPower(self, channel=None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10 * numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Spectra(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.data_dc = None
                     self.data_spc = None
                     self.data_cspc = None
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
                     self.timeZone = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                     self.spc_noise = None
                     self.metadata_list = ['type', 'heightList', 'timeZone', 'pairsList', 'channelList', 'nCohInt',
                         'code', 'nCode', 'nBaud', 'ippSeconds', 'ipp', 'nIncohInt', 'nFFTPoints', 'nProfiles', 'flagDecodeData']
                 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):
                         #print(self.data_spc[0])
                         #exit(1)
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
+                        #print("daux",daux)
                         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.spc_noise is not None:
                         # this was estimated by getNoise Operation defined in jroproc_parameters.py
                         return self.spc_noise
                     elif self.noise_estimation is not None:
                         # this was estimated by getNoise Operation defined in jroproc_spectra.py
                         return self.noise_estimation
                     else:
                         noise = self.getNoisebyHildebrand(
                             xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * (numpy.arange(self.nFFTPoints + extrapoints) -self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints * self.ippFactor)
                     velrange = deltav * (numpy.arange(self.nFFTPoints + extrapoints) - self.nFFTPoints / 2.)
                     if self.nmodes:
                         return velrange/self.nmodes
                     else:
                         return velrange
                 @property
                 def nPairs(self):
                     return len(self.pairsList)
                 @property
                 def pairsIndexList(self):
                     return list(range(self.nPairs))
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                         #pwcode = 64
                         #print("pwcode: ", pwcode)
                         #exit(1)
                     #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
                 @property
                 def flag_cspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 @property
                 def flag_dc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
                     if self.nmodes:
                         return self.nmodes*timeInterval
                     else:
                         return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     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
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
             class SpectraHeis(Spectra):
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 @property
                 def normFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nIncohInt
             class Fits(JROData):
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
                     self.timeZone = 0
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 @property
                 def timeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 @property
                 def ippSeconds(self):
                     '''
                     '''
                     return self.ipp_sec
                 noise = property(getNoise, "I'm the 'nHeights' property.")
             class Correlation(JROData):
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = 0
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode=2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:, :, indR, :]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
                         ind_vel[list(range(0, 1))] = ind_vel[list(
                             range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                             jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
                             xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
                             junkid = jspectra[ich, freq_dc, :] <= 0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich, freq_dc, junkid.nonzero()] = (
                                     jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                     noise = jspectra0[:, freq_dc, :] - jspectra[:, freq_dc, :]
                     return noise
                 @property
                 def timeInterval(self):
                     return self.ippSeconds * self.nCohInt * self.nProfiles
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         # Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 @property
                 def normFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs == ch0, :, :], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs == ch1, :, :], axis=1)
                         normFactor[p, :] = numpy.sqrt(ch0_max * ch1_max)
                     return normFactor
             class Parameters(Spectra):
                 groupList = None  # List of Pairs, Groups, etc
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
                 abscissaList = None  # Abscissa, can be velocities, lags or time
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 # Fitting
                 data_error = None  # Error of the estimation
                 constants = None
                 library = None
                 # Output signal
                 outputInterval = None  # Time interval to calculate output signal in seconds
                 data_output = None  # Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 spc_noise = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                     self.timeZone = 0
                     self.ippFactor = 1
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone * 60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 @property
                 def timeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 noise = property(getNoise, setValue, "I'm the 'Noise' property.")
             class PlotterData(object):
                 '''
                 Object to hold data to be plotted
                 '''
                 MAXNUMX = 200
                 MAXNUMY = 200
                 def __init__(self, code, exp_code, localtime=True):
                     self.key = code
                     self.exp_code = exp_code
                     self.ready = False
                     self.flagNoData = False
                     self.localtime = localtime
                     self.data = {}
                     self.meta = {}
                     self.__heights = []
                 def __str__(self):
                     dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
                     return 'Data[{}][{}]'.format(';'.join(dum), len(self.times))
                 def __len__(self):
                     return len(self.data)
                 def __getitem__(self, key):
                     if isinstance(key, int):
                         return self.data[self.times[key]]
                     elif isinstance(key, str):
                         ret = numpy.array([self.data[x][key] for x in self.times])
                         if ret.ndim > 1:
                             ret = numpy.swapaxes(ret, 0, 1)
                         return ret
                 def __contains__(self, key):
                     return key in self.data[self.min_time]
                 def setup(self):
                     '''
                     Configure object
                     '''
                     self.type = ''
                     self.ready = False
                     del self.data
                     self.data = {}
                     self.__heights = []
                     self.__all_heights = set()
                 def shape(self, key):
                     '''
                     Get the shape of the one-element data for the given key
                     '''
                     if len(self.data[self.min_time][key]):
                         return self.data[self.min_time][key].shape
                     return (0,)
                 def update(self, data, tm, meta={}):
                     '''
                     Update data object with new dataOut
                     '''
                     self.data[tm] = data
                     for key, value in meta.items():
                         setattr(self, key, value)
                 def normalize_heights(self):
                     '''
                     Ensure same-dimension of the data for different heighList
                     '''
                     H = numpy.array(list(self.__all_heights))
                     H.sort()
                     for key in self.data:
                         shape = self.shape(key)[:-1] + H.shape
                         for tm, obj in list(self.data[key].items()):
                             h = self.__heights[self.times.tolist().index(tm)]
                             if H.size == h.size:
                                 continue
                             index = numpy.where(numpy.in1d(H, h))[0]
                             dummy = numpy.zeros(shape) + numpy.nan
                             if len(shape) == 2:
                                 dummy[:, index] = obj
                             else:
                                 dummy[index] = obj
                             self.data[key][tm] = dummy
                     self.__heights = [H for tm in self.times]
                 def jsonify(self, tm, plot_name, plot_type, decimate=False):
                     '''
                     Convert data to json
                     '''
                     meta = {}
                     meta['xrange'] = []
                     dy = int(len(self.yrange)/self.MAXNUMY) + 1
                     tmp = self.data[tm][self.key]
                     shape = tmp.shape
                     if len(shape) == 2:
                         data = self.roundFloats(self.data[tm][self.key][::, ::dy].tolist())
                     elif len(shape) == 3:
                         dx = int(self.data[tm][self.key].shape[1]/self.MAXNUMX) + 1
                         data = self.roundFloats(
                             self.data[tm][self.key][::, ::dx, ::dy].tolist())
                         meta['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
                     else:
                         data = self.roundFloats(self.data[tm][self.key].tolist())
                     ret = {
                         'plot': plot_name,
                         'code': self.exp_code,
                         'time': float(tm),
                         'data': data,
                         }
                     meta['type'] = plot_type
                     meta['interval'] = float(self.interval)
                     meta['localtime'] = self.localtime
                     meta['yrange'] = self.roundFloats(self.yrange[::dy].tolist())
                     meta.update(self.meta)
                     ret['metadata'] = meta
                     return json.dumps(ret)
                 @property
                 def times(self):
                     '''
                     Return the list of times of the current data
                     '''
                     ret = [t for t in self.data]
                     ret.sort()
                     return numpy.array(ret)
                 @property
                 def min_time(self):
                     '''
                     Return the minimun time value
                     '''
                     return self.times[0]
                 @property
                 def max_time(self):
                     '''
                     Return the maximun time value
                     '''
                     return self.times[-1]
                 # @property
                 # def heights(self):
                 #     '''
                 #     Return the list of heights of the current data
                 #     '''
                 #     return numpy.array(self.__heights[-1])
                 @staticmethod
                 def roundFloats(obj):
                     if isinstance(obj, list):
                         return list(map(PlotterData.roundFloats, obj))
                     elif isinstance(obj, float):
                         return round(obj, 2)

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

             # Copyright (c) 2012-2021 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plot Spectra data
             """
             import os
             import numpy
             #import collections.abc
             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     #print("dataOut.normFactor: ", dataOut.normFactor)
                     #print("spc: ", dataOut.data_spc[0,0,0])
                     #spc = 10*numpy.log10(dataOut.data_spc)
                     #print("Spc: ",spc[0])
                     #exit(1)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     #print(data['rti'][0])
                     #exit(1)
                     #print("NormFactor: ",dataOut.normFactor)
                     #data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     if hasattr(dataOut, 'LagPlot'): #Double Pulse
-                        max_hei_id = dataOut.nHeights - 2*dataOut.LagPlot
+                        ymin_index =  numpy.abs(dataOut.heightList - 800).argmin()
-                        #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=46,ymax_index=max_hei_id)/dataOut.normFactor)
+                        max_hei_id = dataOut.nHeights - dataOut.TxLagRate*dataOut.LagPlot
-                        #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=40,ymax_index=max_hei_id)/dataOut.normFactor)
+                        data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=ymin_index,ymax_index=max_hei_id)/dataOut.normFactor)
-                        data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=53,ymax_index=max_hei_id)/dataOut.normFactor)
+                        data['noise'][0] = 10*numpy.log10(dataOut.getNoise(ymin_index=ymin_index)[0]/dataOut.normFactor)
-                        data['noise'][0] = 10*numpy.log10(dataOut.getNoise(ymin_index=53)[0]/dataOut.normFactor)
                         #data['noise'][1] = 22.035507
                     else:
                         data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
-                    #data['noise'] = 10*numpy.log10(dataOut.getNoise(ymin_index=26,ymax_index=44)/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                     if self.CODE == 'gaussian_fit':
                         data['gaussfit'] = dataOut.DGauFitParams
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if (self.CODE == 'spc_moments') | (self.CODE == 'gaussian_fit'):
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     self.CODE2 = 'spc_oblique'
                     for n, ax in enumerate(self.axes):
                         noise = data['noise'][n]
                         if self.CODE == 'spc_moments':
                             mean = data['moments'][n, 1]
                         if self.CODE == 'gaussian_fit':
                             gau0 = data['gaussfit'][n][2,:,0]
                             gau1 = data['gaussfit'][n][2,:,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else numpy.nanmin(x)#-self.xmax
                             #self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             #self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap),
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0 = ax.plot(gau0, y, color='r', lw=1)[0]
                                 ax.plt_gau1 = ax.plot(gau1, y, color='y', lw=1)[0]
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                             if self.CODE == 'gaussian_fit':
                                 ax.plt_gau0.set_data(gau0, y)
                                 ax.plt_gau1.set_data(gau1, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class SpectraObliquePlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc_oblique'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 def setup(self):
                     self.xaxis = "oblique"
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     '''
                     data['shift1'] = dataOut.Oblique_params[0,-2,:]
                     data['shift2'] = dataOut.Oblique_params[0,-1,:]
                     data['shift1_error'] = dataOut.Oblique_param_errors[0,-2,:]
                     data['shift2_error'] = dataOut.Oblique_param_errors[0,-1,:]
                     '''
                     '''
                     data['shift1'] = dataOut.Oblique_params[0,1,:]
                     data['shift2'] = dataOut.Oblique_params[0,4,:]
                     data['shift1_error'] = dataOut.Oblique_param_errors[0,1,:]
                     data['shift2_error'] = dataOut.Oblique_param_errors[0,4,:]
                     '''
                     data['shift1'] = dataOut.Dop_EEJ_T1[0]
                     data['shift2'] = dataOut.Dop_EEJ_T2[0]
                     data['max_val_2'] = dataOut.Oblique_params[0,-1,:]
                     data['shift1_error'] = dataOut.Err_Dop_EEJ_T1[0]
                     data['shift2_error'] = dataOut.Err_Dop_EEJ_T2[0]
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         shift1 = data['shift1']
                         #print(shift1)
                         shift2 = data['shift2']
                         max_val_2 = data['max_val_2']
                         err1 = data['shift1_error']
                         err2 = data['shift2_error']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             #print("plotter1: ", self.ploterr1,shift1)
                         else:
                             #print("else plotter1: ", self.ploterr1,shift1)
                             self.ploterr1.remove()
                             self.ploterr2.remove()
                             self.ploterr3.remove()
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             self.ploterr1 = ax.errorbar(shift1, y, xerr=err1, fmt='k^', elinewidth=2.2, marker='o', linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr2 = ax.errorbar(shift2, y, xerr=err2, fmt='m^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                             self.ploterr3 = ax.errorbar(max_val_2, y, xerr=0, fmt='g^',elinewidth=2.2,marker='o',linestyle='None',markersize=2.5,capsize=0.3,markeredgewidth=0.2)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nplots = len(self.data.pairs) * 2
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     meta['pairs'] = dataOut.pairsList
                     tmp = []
                     for n, pair in enumerate(meta['pairs']):
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         tmp.append(coh)
                         tmp.append(phase)
                     data['cspc'] = numpy.array(tmp)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     cspc = data['cspc']
                     for n in range(len(self.data.pairs)):
                         pair = self.data.pairs[n]
                         coh = cspc[n*2]
                         phase = cspc[n*2+1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=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[2 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra4Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     spc = self.data['cspc'][0]
                     #print(numpy.shape(nspc))
                     #exit()
                     #nspc[1,:,:] = numpy.flip(nspc[1,:,:],axis=0)
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #xflip=numpy.flip(x)
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)
                         #exit()
                         ax = self.axes[4 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(nspc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(nspc)
                             ax.plt = ax.pcolormesh(x , y , nspc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             #print(numpy.shape(nspc[pair[0]].T))
                             #exit()
                             ax.plt.set_array(nspc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[0], noise[pair[0]]))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x , y, numpy.flip(nspc[pair[1]],axis=0).T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(nspc[pair[1]],axis=0).T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(pair[1], noise[pair[1]]))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(coh,axis=0).T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(coh,axis=0).T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, numpy.flip(phase,axis=0).T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(numpy.flip(phase,axis=0).T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class CrossSpectra2Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 1
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     #nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     #spc = self.data['cspc'][0]
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)            #exit()
                         out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         #print(out[:,53])
                         #exit()
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         #print("here")
                         #print(dataOut.data_spc[0,0,0])
                         #exit()
                         cross = 10*numpy.log10(z)
                         #print(numpy.shape(cross))
                         #print(cross[0,:])
                         #print(self.data.nFactor)
                         #exit()
                         #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[1 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
             class CrossSpectra3Plot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 3
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 3
                     self.width = 3.1 * self.ncols
                     self.height = 5 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.22, 'right': .90, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     #nspc = self.data['spc']
                     #print(numpy.shape(self.data['spc']))
                     #spc = self.data['cspc'][0]
                     #print(numpy.shape(spc))
                     #exit()
                     cspc = self.data['cspc'][1]
                     #print(numpy.shape(cspc))
                     #exit()
                     for n in range(self.nrows):
                         noise = self.data['noise'][:,-1]
                         pair = self.data.pairs[n]
                         #print(pair)            #exit()
                         out = cspc[n]# / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         #print(out[:,53])
                         #exit()
                         cross = numpy.abs(out)
                         z = cross/self.data.nFactor
                         cross = 10*numpy.log10(z)
                         out_r= out.real/self.data.nFactor
                         #out_r = 10*numpy.log10(out_r)
                         out_i= out.imag/self.data.nFactor
                         #out_i = 10*numpy.log10(out_i)
                         #print(numpy.shape(cross))
                         #print(cross[0,:])
                         #print(self.data.nFactor)
                         #exit()
                         #phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[3 * n]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, cross.T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(cross.T.ravel())
                         self.titles.append(
                             'Cross Spectra Power Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_r.T,
                                                    vmin=-1.e6,
                                                    vmax=0,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_r.T.ravel())
                         self.titles.append(
                             'Cross Spectra Real Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[3 * n + 2]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(cross)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(cross)
                             ax.plt = ax.pcolormesh(x, y, out_i.T,
                                                    vmin=-1.e6,
                                                    vmax=1.e6,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(out_i.T.ravel())
                         self.titles.append(
                             'Cross Spectra Imag Ch{} * Ch{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
                     #print(numpy.shape(data['rti']))
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     #print("Inside RTI: ", self.z)
                     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())
                     #print("self.z: ", self.z)
                     #exit(1)
                     '''
                     if not isinstance(self.zmin, collections.abc.Sequence):
                         if not self.zmin:
                             self.zmin = [numpy.min(self.z)]*len(self.axes)
                         else:
                             self.zmin = [self.zmin]*len(self.axes)
                     if not isinstance(self.zmax, collections.abc.Sequence):
                         if not self.zmax:
                             self.zmax = [numpy.max(self.z)]*len(self.axes)
                         else:
                             self.zmax = [self.zmax]*len(self.axes)
                             '''
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=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:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.remove()
                             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 SpectrogramPlot(Plot):
                 '''
                 Plot for Spectrogram data
                 '''
                 CODE = 'Spectrogram_Profile'
                 colormap = 'binary'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.xlabel = 'Time'
                     #self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':1.2, 'left': 0.1, 'bottom': 0.12, 'right':0.95})
                     self.titles = []
                     #self.titles = ['{} Channel {} \n H = {} km ({} - {})'.format(
                         #self.CODE.upper(), x, self.data.heightList[self.data.hei], self.data.heightList[self.data.hei],self.data.heightList[self.data.hei]+(self.data.DH*self.data.nProfiles)) for x in range(self.nrows)]
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     maxHei = 1620#+12000
                     maxHei = 1180
                     maxHei = 500
                     indb = numpy.where(dataOut.heightList <= maxHei)
                     hei = indb[0][-1]
                     #print(dataOut.heightList)
                     factor = dataOut.nIncohInt
                     z = dataOut.data_spc[:,:,hei] / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     #buffer = 10 * numpy.log10(z)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     #self.hei = hei
                     #self.heightList = dataOut.heightList
                     #self.DH = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
                     #self.nProfiles = dataOut.nProfiles
                     data['Spectrogram_Profile'] = 10 * numpy.log10(z)
                     data['hei'] = hei
                     data['DH'] = (dataOut.heightList[1] - dataOut.heightList[0])/dataOut.step
                     data['nProfiles'] = dataOut.nProfiles
                     #meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     '''
                     import matplotlib.pyplot as plt
                     plt.plot(10 * numpy.log10(z[0,:]))
                     plt.show()
                     from time import sleep
                     sleep(10)
                     '''
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.z = self.data[self.CODE]
                     self.y = self.data.xrange[0]
                     hei = self.data['hei'][-1]
                     DH = self.data['DH'][-1]
                     nProfiles = self.data['nProfiles'][-1]
                     self.ylabel = "Frequency (kHz)"
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.remove()
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                     #self.titles.append('Spectrogram')
                     #self.titles.append('{} Channel {} \n H = {} km ({} - {})'.format(
                         #self.CODE.upper(), x, y[hei], y[hei],y[hei]+(DH*nProfiles)))
             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]'
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['coh'] = dataOut.getCoherence()
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['phase'] = dataOut.getCoherence(phase=True)
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
                     meta['yrange'] = numpy.array([])
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['noise']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5
                         self.ymax = numpy.nanmax(Y) + 5
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 10
             class PowerProfilePlot(Plot):
                 CODE = 'pow_profile'
                 plot_type = 'scatter'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data[self.CODE] = dataOut.getPower()
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.y = y
                     x = self.data[-1][self.CODE]
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 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 + 1.5
                     self.height = 3 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'cut_gaussian_fit':
                         data['gauss_fit0'] = 10*numpy.log10(dataOut.GaussFit0/dataOut.normFactor)
                         data['gauss_fit1'] = 10*numpy.log10(dataOut.GaussFit1/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][1:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'cut_gaussian_fit':
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     data = self.data[-1]
                     z = data['spc']
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
                         index = numpy.arange(0, len(y), int((len(y))/9))
                     for n, ax in enumerate(self.axes):
                         if self.CODE == 'cut_gaussian_fit':
                             gau0 = data['gauss_fit0']
                             gau1 = data['gauss_fit1']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z[:,:,index])
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z[:,:,index])
                             #print(self.ymax)
                             #print(z[n, :, index])
                             ax.plt = ax.plot(x, z[n, :, index].T, lw=0.25)
                             if self.CODE == 'cut_gaussian_fit':
                                 ax.plt_gau0 = ax.plot(x, gau0[n, :, index].T, lw=1, linestyle='-.')
                                 for i, line in enumerate(ax.plt_gau0):
                                     line.set_color(ax.plt[i].get_color())
                                 ax.plt_gau1 = ax.plot(x, gau1[n, :, index].T, lw=1, linestyle='--')
                                 for i, line in enumerate(ax.plt_gau1):
                                     line.set_color(ax.plt[i].get_color())
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, index[i]].T)
                             for i, line in enumerate(ax.plt_gau0):
                                 line.set_data(x, gau0[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                             for i, line in enumerate(ax.plt_gau1):
                                 line.set_data(x, gau1[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                         self.titles.append('CH {}'.format(n))
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = 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/jroplot_voltage_lags.py +1 -1

             import os
             import time
             import math
             import datetime
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator  #YONG
             from .jroplot_spectra import RTIPlot, NoisePlot
             from schainpy.utils import log
             from .plotting_codes import *
             from schainpy.model.graphics.jroplot_base import Plot, plt
             import matplotlib.pyplot as plt
             import matplotlib.colors as colors
             from matplotlib.ticker import MultipleLocator, LogLocator, NullFormatter
             class RTIDPPlot(RTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''Plot for RTI Double Pulse Experiment Using Cross Products Analysis
                 '''
                 CODE = 'RTIDP'
                 colormap = 'jet'
                 plot_name = 'RTI'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 3
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.cb_label = 'Intensity (dB)'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.plot_name.upper(), '0x1'),'{} Channel {}'.format(
                             self.plot_name.upper(), '0'),'{} Channel {}'.format(
                                 self.plot_name.upper(), '1')]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.data_for_RTI_DP
                     data['NDP'] = dataOut.NDP
                     return data, meta
                 def plot(self):
                     NDP = self.data['NDP'][-1]
                     self.x = self.data.times
                     self.y = self.data.yrange[0:NDP]
                     self.z = self.data['rti']
                     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[1][0,12:40])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[1][0,12:40])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             #if self.zlimits is not None:
                                 #self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.remove()
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
             class RTILPPlot(RTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for RTI Long Pulse Using Cross Products Analysis
                 '''
                 CODE = 'RTILP'
                 colormap = 'jet'
                 plot_name = 'RTI LP'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 2
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.cb_label = 'Intensity (dB)'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.1, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.plot_name.upper(), '0'),'{} Channel {}'.format(
                             self.plot_name.upper(), '1'),'{} Channel {}'.format(
                                 self.plot_name.upper(), '2'),'{} Channel {}'.format(
                                     self.plot_name.upper(), '3')]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.data_for_RTI_LP
                     data['NRANGE'] = dataOut.NRANGE
                     return data, meta
                 def plot(self):
                     NRANGE = self.data['NRANGE'][-1]
                     self.x = self.data.times
                     self.y = self.data.yrange[0:NRANGE]
                     self.z = self.data['rti']
                     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[1][0,12:40])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[1][0,12:40])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.remove()
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
             class DenRTIPlot(RTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    RTI Plot for Electron Densities
                 '''
                 CODE = 'denrti'
                 colormap = 'jet'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     if self.CODE == 'denrti':
                         self.cb_label = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
                     self.titles = ['Electron Density RTI']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['denrti'] = dataOut.DensityFinal*1.e-6 #To Plot in cm^-3
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.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]
                             if numpy.log10(self.zmin)<0:
                                 self.zmin=1
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    #vmin=self.zmin,
                                                    #vmax=self.zmax,
                                                    cmap=self.cmaps[n],
                                                    norm=colors.LogNorm(vmin=self.zmin,vmax=self.zmax)
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.remove()
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    #vmin=self.zmin,
                                                    #vmax=self.zmax,
                                                    cmap=self.cmaps[n],
                                                    norm=colors.LogNorm(vmin=self.zmin,vmax=self.zmax)
                                                    )
             class ETempRTIPlot(RTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for Electron Temperature
                 '''
                 CODE = 'ETemp'
                 colormap = 'jet'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time (LT)'
                     self.plots_adjust.update({'wspace': 0.8, 'hspace':0.2, 'left': 0.2, 'right': 0.9, 'bottom': 0.18})
                     if self.CODE == 'ETemp':
                         self.cb_label = 'Electron Temperature (K)'
                         self.titles = ['Electron Temperature RTI']
                     if self.CODE == 'ITemp':
                         self.cb_label = 'Ion Temperature (K)'
                         self.titles = ['Ion Temperature RTI']
                     if self.CODE == 'HeFracLP':
                         self.cb_label ='He+ Fraction'
                         self.titles = ['He+ Fraction RTI']
                         self.zmax=0.16
                     if self.CODE == 'HFracLP':
                         self.cb_label ='H+ Fraction'
                         self.titles = ['H+ Fraction RTI']
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ETemp'] = dataOut.ElecTempFinal
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.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]
                                                    )
                             #plt.tight_layout()
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt.remove()
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class ITempRTIPlot(ETempRTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for Ion Temperature
                 '''
                 CODE = 'ITemp'
                 colormap = 'jet'
                 plot_name = 'Ion Temperature'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ITemp'] = dataOut.IonTempFinal
                     return data, meta
             class HFracRTIPlot(ETempRTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for H+ LP
                 '''
                 CODE = 'HFracLP'
                 colormap = 'jet'
                 plot_name = 'H+ Frac'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['HFracLP'] = dataOut.PhyFinal
                     return data, meta
             class HeFracRTIPlot(ETempRTIPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for He+ LP
                 '''
                 CODE = 'HeFracLP'
                 colormap = 'jet'
                 plot_name = 'He+ Frac'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['HeFracLP'] = dataOut.PheFinal
                     return data, meta
             class TempsDPPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for Electron - Ion Temperatures
                 '''
                 CODE = 'tempsDP'
                 #plot_name = 'Temperatures'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Temperature (K)'
                     self.titles = ['Electron/Ion Temperatures']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['Te'] = dataOut.te2
                     data['Ti'] = dataOut.ti2
                     data['Te_error'] = dataOut.ete2
                     data['Ti_error'] = dataOut.eti2
                     meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.xmin = -100
                     self.xmax = 5000
                     ax = self.axes[0]
                     data = self.data[-1]
                     Te = data['Te']
                     Ti = data['Ti']
                     errTe = data['Te_error']
                     errTi = data['Ti_error']
                     if ax.firsttime:
                         ax.errorbar(Te, y, xerr=errTe, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, y, fmt='k^', xerr=errTi,elinewidth=1.0,color='k',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         self.ystep_given = 50
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(Te, y, xerr=errTe, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, y, fmt='k^', xerr=errTi,elinewidth=1.0,color='k',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class TempsHPPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for Temperatures Hybrid Experiment
                 '''
                 CODE = 'temps_LP'
                 #plot_name = 'Temperatures'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Temperature (K)'
                     self.titles = ['Electron/Ion Temperatures']
                     self.width = 3.5
                     self.height = 6.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['Te'] = numpy.concatenate((dataOut.te2[:dataOut.cut],dataOut.te[dataOut.cut:]))
                     data['Ti'] = numpy.concatenate((dataOut.ti2[:dataOut.cut],dataOut.ti[dataOut.cut:]))
                     data['Te_error'] = numpy.concatenate((dataOut.ete2[:dataOut.cut],dataOut.ete[dataOut.cut:]))
                     data['Ti_error'] = numpy.concatenate((dataOut.eti2[:dataOut.cut],dataOut.eti[dataOut.cut:]))
                     meta['yrange'] = dataOut.heightList[0:dataOut.NACF]
                     return data, meta
                 def plot(self):
                     self.y = self.data.yrange
                     self.xmin = -100
                     self.xmax = 4500
                     ax = self.axes[0]
                     data = self.data[-1]
                     Te = data['Te']
                     Ti = data['Ti']
                     errTe = data['Te_error']
                     errTi = data['Ti_error']
                     if ax.firsttime:
                         ax.errorbar(Te, self.y, xerr=errTe, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, self.y, fmt='k^', xerr=errTi,elinewidth=1.0,color='',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(Te, self.y, xerr=errTe, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='Te')
                         ax.errorbar(Ti, self.y, fmt='k^', xerr=errTi,elinewidth=1.0,color='k',linewidth=2.0, label='Ti')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
             class FracsHPPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for Composition LP
                 '''
                 CODE = 'fracs_LP'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Frac'
                     self.titles = ['Composition']
                     self.width = 3.5
                     self.height = 6.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     #aux_nan=numpy.zeros(dataOut.cut,'float32')
                     #aux_nan[:]=numpy.nan
                     #data['ph'] = numpy.concatenate((aux_nan,dataOut.ph[dataOut.cut:]))
                     #data['eph'] = numpy.concatenate((aux_nan,dataOut.eph[dataOut.cut:]))
                     data['ph'] = dataOut.ph[dataOut.cut:]
                     data['eph'] = dataOut.eph[dataOut.cut:]
                     data['phe'] = dataOut.phe[dataOut.cut:]
                     data['ephe'] = dataOut.ephe[dataOut.cut:]
                     data['cut'] = dataOut.cut
                     meta['yrange'] = dataOut.heightList[0:dataOut.NACF]
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     ph = data['ph']
                     eph = data['eph']
                     phe = data['phe']
                     ephe = data['ephe']
                     cut = data['cut']
                     self.y = self.data.yrange
                     self.xmin = 0
                     self.xmax = 1
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.errorbar(ph, self.y[cut:], xerr=eph, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='H+')
                         ax.errorbar(phe, self.y[cut:], fmt='k^', xerr=ephe,elinewidth=1.0,color='k',linewidth=2.0, label='He+')
                         plt.legend(loc='lower right')
                         self.xstep_given = 0.2
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         ax.errorbar(ph, self.y[cut:], xerr=eph, fmt='r^',elinewidth=1.0,color='r',linewidth=2.0, label='H+')
                         ax.errorbar(phe, self.y[cut:], fmt='k^', xerr=ephe,elinewidth=1.0,color='k',linewidth=2.0, label='He+')
                         plt.legend(loc='lower right')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
             class EDensityPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for electron density
                 '''
                 CODE = 'den'
                 #plot_name = 'Electron Density'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = r'$\mathrm{N_e}$ Electron Density ($\mathrm{1/cm^3}$)'
                     self.titles = ['Electron Density']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['den_power'] = dataOut.ph2[:dataOut.NSHTS]
                     data['den_Faraday'] = dataOut.dphi[:dataOut.NSHTS]
                     data['den_error'] = dataOut.sdp2[:dataOut.NSHTS]
                     #data['err_Faraday'] = dataOut.sdn1[:dataOut.NSHTS]
                     #print(numpy.shape(data['den_power']))
                     #print(numpy.shape(data['den_Faraday']))
                     #print(numpy.shape(data['den_error']))
                     data['NSHTS'] = dataOut.NSHTS
                     meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     #self.xmin = 1e3
                     #self.xmax = 1e7
                     ax = self.axes[0]
                     data = self.data[-1]
                     DenPow = data['den_power']
                     DenFar = data['den_Faraday']
                     errDenPow = data['den_error']
                     #errFaraday = data['err_Faraday']
                     NSHTS = data['NSHTS']
                     if self.CODE == 'denLP':
                         DenPowLP = data['den_LP']
                         errDenPowLP = data['den_LP_error']
                         cut = data['cut']
                     if ax.firsttime:
                         self.autoxticks=False
                         #ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
                         ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday',markersize=2,linestyle='-')
                         #ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
                         ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='k',linewidth=1.0, label='Power',markersize=2,linestyle='-')
                         if self.CODE=='denLP':
                             ax.errorbar(DenPowLP[cut:], y[cut:], xerr=errDenPowLP[cut:], fmt='r^-',elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
                         ax.set_xscale("log")#, nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         self.ystep_given=100
                         if self.CODE=='denLP':
                             self.ystep_given=200
                         ax.set_yticks(grid_y_ticks,minor=True)
                         locmaj = LogLocator(base=10,numticks=12)
                         ax.xaxis.set_major_locator(locmaj)
                         locmin = LogLocator(base=10.0,subs=(0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9),numticks=12)
                         ax.xaxis.set_minor_locator(locmin)
                         ax.xaxis.set_minor_formatter(NullFormatter())
                         ax.grid(which='minor')
                     else:
                         dataBefore = self.data[-2]
                         DenPowBefore = dataBefore['den_power']
                         self.clear_figures()
                         #ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday Profile',markersize=2)
                         ax.errorbar(DenFar, y[:NSHTS], xerr=1, fmt='h-',elinewidth=1.0,color='g',linewidth=1.0, label='Faraday',markersize=2,linestyle='-')
                         #ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='b',linewidth=1.0, label='Power Profile',markersize=2)
                         ax.errorbar(DenPow, y[:NSHTS], fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='k',linewidth=1.0, label='Power',markersize=2,linestyle='-')
                         ax.errorbar(DenPowBefore, y[:NSHTS], elinewidth=1.0,color='r',linewidth=0.5,linestyle="dashed")
                         if self.CODE=='denLP':
                             ax.errorbar(DenPowLP[cut:], y[cut:], fmt='r^-', xerr=errDenPowLP[cut:],elinewidth=1.0,color='r',linewidth=1.0, label='LP Profile',markersize=2)
                         ax.set_xscale("log")#, nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         ax.set_yticks(grid_y_ticks,minor=True)
                         locmaj = LogLocator(base=10,numticks=12)
                         ax.xaxis.set_major_locator(locmaj)
                         locmin = LogLocator(base=10.0,subs=(0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9),numticks=12)
                         ax.xaxis.set_minor_locator(locmin)
                         ax.xaxis.set_minor_formatter(NullFormatter())
                         ax.grid(which='minor')
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
             class RelativeDenPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for electron density
                 '''
                 CODE = 'den'
                 #plot_name = 'Electron Density'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = r'$\mathrm{N_e}$ Relative Electron Density ($\mathrm{1/cm^3}$)'
                     self.titles = ['Electron Density']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['den_power'] = dataOut.ph2
                     data['den_error'] = dataOut.sdp2
                     meta['yrange'] = dataOut.heightList
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     ax = self.axes[0]
                     data = self.data[-1]
                     DenPow = data['den_power']
                     errDenPow = data['den_error']
                     if ax.firsttime:
                         self.autoxticks=False
                         ax.errorbar(DenPow, y, fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='k',linewidth=1.0, label='Power',markersize=2,linestyle='-')
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
                         ax.set_xscale("log")#, nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         self.ystep_given=100
                         ax.set_yticks(grid_y_ticks,minor=True)
                         locmaj = LogLocator(base=10,numticks=12)
                         ax.xaxis.set_major_locator(locmaj)
                         locmin = LogLocator(base=10.0,subs=(0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9),numticks=12)
                         ax.xaxis.set_minor_locator(locmin)
                         ax.xaxis.set_minor_formatter(NullFormatter())
                         ax.grid(which='minor')
                     else:
                         dataBefore = self.data[-2]
                         DenPowBefore = dataBefore['den_power']
                         self.clear_figures()
                         ax.errorbar(DenPow, y, fmt='k^-', xerr=errDenPow,elinewidth=1.0,color='k',linewidth=1.0, label='Power',markersize=2,linestyle='-')
                         ax.errorbar(DenPowBefore, y, elinewidth=1.0,color='r',linewidth=0.5,linestyle="dashed")
                         ax.set_xscale("log")#, nonposx='clip')
                         grid_y_ticks=numpy.arange(numpy.nanmin(y),numpy.nanmax(y),50)
                         ax.set_yticks(grid_y_ticks,minor=True)
                         locmaj = LogLocator(base=10,numticks=12)
                         ax.xaxis.set_major_locator(locmaj)
                         locmin = LogLocator(base=10.0,subs=(0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9),numticks=12)
                         ax.xaxis.set_minor_locator(locmin)
                         ax.xaxis.set_minor_formatter(NullFormatter())
                         ax.grid(which='minor')
                         plt.legend(loc='upper left',fontsize=8.5)
                         #plt.legend(loc='lower left',fontsize=8.5)
             class FaradayAnglePlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for electron density
                 '''
                 CODE = 'angle'
                 plot_name = 'Faraday Angle'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Faraday Angle (º)'
                     self.titles = ['Electron Density']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['angle'] = numpy.degrees(dataOut.phi)
                     #'''
                     #print(dataOut.phi_uwrp)
                     #print(data['angle'])
                     #exit(1)
                     #'''
                     data['dphi'] = dataOut.dphi_uc*10
                     #print(dataOut.dphi)
                     #data['NSHTS'] = dataOut.NSHTS
                     #meta['yrange'] = dataOut.heightList[0:dataOut.NSHTS]
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     self.x = data[self.CODE]
                     dphi = data['dphi']
                     self.y = self.data.yrange
                     self.xmin = -360#-180
                     self.xmax = 360#180
                     ax = self.axes[0]
                     if ax.firsttime:
                         self.autoxticks=False
                         #if self.CODE=='den':
                         ax.plot(self.x, self.y,marker='o',color='g',linewidth=1.0,markersize=2)
                         ax.plot(dphi, self.y,marker='o',color='blue',linewidth=1.0,markersize=2)
                         grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
                         self.ystep_given=100
                         if self.CODE=='denLP':
                             self.ystep_given=200
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
                         #plt.tight_layout()
                     else:
                         self.clear_figures()
                         #if self.CODE=='den':
                         #print(numpy.shape(self.x))
                         ax.plot(self.x, self.y, marker='o',color='g',linewidth=1.0, markersize=2)
                         ax.plot(dphi, self.y,marker='o',color='blue',linewidth=1.0,markersize=2)
                         grid_y_ticks=numpy.arange(numpy.nanmin(self.y),numpy.nanmax(self.y),50)
                         ax.set_yticks(grid_y_ticks,minor=True)
                         ax.grid(which='minor')
             class EDensityHPPlot(EDensityPlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                    Plot for Electron Density Hybrid Experiment
                 '''
                 CODE = 'denLP'
                 plot_name = 'Electron Density'
                 plot_type = 'scatterbuffer'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['den_power'] = dataOut.ph2[:dataOut.NSHTS]
                     data['den_Faraday']=dataOut.dphi[:dataOut.NSHTS]
                     data['den_error']=dataOut.sdp2[:dataOut.NSHTS]
                     data['den_LP']=dataOut.ne[:dataOut.NACF]
                     data['den_LP_error']=dataOut.ene[:dataOut.NACF]*dataOut.ne[:dataOut.NACF]*0.434
                     #self.ene=10**dataOut.ene[:dataOut.NACF]
                     data['NSHTS']=dataOut.NSHTS
                     data['cut']=dataOut.cut
                     return data, meta
             class ACFsPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for ACFs Double Pulse Experiment
                 '''
                 CODE = 'acfs'
                 #plot_name = 'ACF'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Lag (ms)'
                     self.titles = ['ACFs']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['ACFs'] = dataOut.acfs_to_plot
                     data['ACFs_error'] = dataOut.acfs_error_to_plot
                     data['lags'] = dataOut.lags_to_plot
                     data['Lag_contaminated_1'] = dataOut.x_igcej_to_plot
                     data['Lag_contaminated_2'] = dataOut.x_ibad_to_plot
                     data['Height_contaminated_1'] = dataOut.y_igcej_to_plot
                     data['Height_contaminated_2'] = dataOut.y_ibad_to_plot
                     meta['yrange'] = numpy.array([])
                     #meta['NSHTS'] = dataOut.NSHTS
                     #meta['DPL'] = dataOut.DPL
                     data['NSHTS'] = dataOut.NSHTS #This is metadata
                     data['DPL'] = dataOut.DPL #This is metadata
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     #NSHTS = self.meta['NSHTS']
                     #DPL = self.meta['DPL']
                     NSHTS = data['NSHTS'] #This is metadata
                     DPL = data['DPL'] #This is metadata
                     lags = data['lags']
                     ACFs = data['ACFs']
                     errACFs = data['ACFs_error']
                     BadLag1 = data['Lag_contaminated_1']
                     BadLag2 = data['Lag_contaminated_2']
                     BadHei1 = data['Height_contaminated_1']
                     BadHei2 = data['Height_contaminated_2']
                     self.xmin = 0.0
-                    self.xmax = 2.0
+                    #self.xmax = 2.0
                     self.y = ACFs
                     ax = self.axes[0]
                     if ax.firsttime:
                         for i in range(NSHTS):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             x_igcej_aux = numpy.isfinite(BadLag1[i,:])
                             y_igcej_aux = numpy.isfinite(BadHei1[i,:])
                             x_ibad_aux = numpy.isfinite(BadLag2[i,:])
                             y_ibad_aux = numpy.isfinite(BadHei2[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',marker='o',linewidth=1.0,markersize=2)
                             ax.plot(BadLag1[i,x_igcej_aux],BadHei1[i,y_igcej_aux],'x',color='red',markersize=2)
                             ax.plot(BadLag2[i,x_ibad_aux],BadHei2[i,y_ibad_aux],'X',color='red',markersize=2)
                         self.xstep_given = (self.xmax-self.xmin)/(DPL-1)
                         self.ystep_given = 50
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         for i in range(NSHTS):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             x_igcej_aux = numpy.isfinite(BadLag1[i,:])
                             y_igcej_aux = numpy.isfinite(BadHei1[i,:])
                             x_ibad_aux = numpy.isfinite(BadLag2[i,:])
                             y_ibad_aux = numpy.isfinite(BadHei2[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],linewidth=1.0,markersize=2,color='b',marker='o')
                             ax.plot(BadLag1[i,x_igcej_aux],BadHei1[i,y_igcej_aux],'x',color='red',markersize=2)
                             ax.plot(BadLag2[i,x_ibad_aux],BadHei2[i,y_ibad_aux],'X',color='red',markersize=2)
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class ACFsLPPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for ACFs Double Pulse Experiment
                 '''
                 CODE = 'acfs_LP'
                 #plot_name = 'ACF'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Lag (ms)'
                     self.titles = ['ACFs']
                     self.width = 3.5
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     aux=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     errors=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     lags_LP_to_plot=numpy.zeros((dataOut.NACF,dataOut.IBITS),'float32')
                     for i in range(dataOut.NACF):
                         for j in range(dataOut.IBITS):
                             if numpy.abs(dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0])<1.0:
                                 aux[i,j]=dataOut.output_LP_integrated.real[j,i,0]/dataOut.output_LP_integrated.real[0,i,0]
                                 aux[i,j]=max(min(aux[i,j],1.0),-1.0)*dataOut.DH+dataOut.heightList[i]
                                 lags_LP_to_plot[i,j]=dataOut.lags_LP[j]
                                 errors[i,j]=dataOut.errors[j,i]/dataOut.output_LP_integrated.real[0,i,0]*dataOut.DH
                             else:
                                 aux[i,j]=numpy.nan
                                 lags_LP_to_plot[i,j]=numpy.nan
                                 errors[i,j]=numpy.nan
                     data['ACFs'] = aux
                     data['ACFs_error'] = errors
                     data['lags'] = lags_LP_to_plot
                     meta['yrange'] = numpy.array([])
                     #meta['NACF'] = dataOut.NACF
                     #meta['NLAG'] = dataOut.NLAG
                     data['NACF'] = dataOut.NACF #This is metadata
                     data['NLAG'] = dataOut.NLAG #This is metadata
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     #NACF = self.meta['NACF']
                     #NLAG = self.meta['NLAG']
                     NACF = data['NACF'] #This is metadata
                     NLAG = data['NLAG'] #This is metadata
                     lags = data['lags']
                     ACFs = data['ACFs']
                     errACFs = data['ACFs_error']
                     self.xmin = 0.0
                     self.xmax = 1.5
                     self.y = ACFs
                     ax = self.axes[0]
                     if ax.firsttime:
                         for i in range(NACF):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
                         #self.xstep_given = (self.xmax-self.xmin)/(self.data.NLAG-1)
                         self.xstep_given=0.3
                         self.ystep_given = 200
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
                         ax.grid(which='minor')
                     else:
                         self.clear_figures()
                         for i in range(NACF):
                             x_aux = numpy.isfinite(lags[i,:])
                             y_aux = numpy.isfinite(ACFs[i,:])
                             yerr_aux = numpy.isfinite(errACFs[i,:])
                             if lags[i,:][~numpy.isnan(lags[i,:])].shape[0]>2:
                                 ax.errorbar(lags[i,x_aux], ACFs[i,y_aux], yerr=errACFs[i,x_aux],color='b',linewidth=1.0,markersize=2,ecolor='r')
                         ax.yaxis.set_minor_locator(MultipleLocator(15))
             class CrossProductsPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for cross products
                 '''
                 CODE = 'crossprod'
                 plot_name = 'Cross Products'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 3
                     self.nrows = 1
                     self.nplots = 3
                     self.ylabel = 'Range [km]'
                     self.titles = []
                     self.width = 3.5*self.nplots
                     self.height = 5.5
                     self.colorbar = False
                     self.plots_adjust.update({'wspace':.3, 'left': 0.12, 'right': 0.92, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['crossprod'] = dataOut.crossprods
                     data['NDP'] = dataOut.NDP
                     return data, meta
                 def plot(self):
                     NDP = self.data['NDP'][-1]
                     x = self.data['crossprod'][:,-1,:,:,:,:]
                     y = self.data.yrange[0:NDP]
                     for n, ax in enumerate(self.axes):
                         self.xmin=numpy.min(numpy.concatenate((x[n][0,20:30,0,0],x[n][1,20:30,0,0],x[n][2,20:30,0,0],x[n][3,20:30,0,0])))
                         self.xmax=numpy.max(numpy.concatenate((x[n][0,20:30,0,0],x[n][1,20:30,0,0],x[n][2,20:30,0,0],x[n][3,20:30,0,0])))
                         if ax.firsttime:
                             self.autoxticks=False
                             if n==0:
                                 label1='kax'
                                 label2='kay'
                                 label3='kbx'
                                 label4='kby'
                                 self.xlimits=[(self.xmin,self.xmax)]
                             elif n==1:
                                 label1='kax2'
                                 label2='kay2'
                                 label3='kbx2'
                                 label4='kby2'
                                 self.xlimits.append((self.xmin,self.xmax))
                             elif n==2:
                                 label1='kaxay'
                                 label2='kbxby'
                                 label3='kaxbx'
                                 label4='kaxby'
                                 self.xlimits.append((self.xmin,self.xmax))
                             ax.plotline1 = ax.plot(x[n][0,:,0,0], y, color='r',linewidth=2.0, label=label1)
                             ax.plotline2 = ax.plot(x[n][1,:,0,0], y, color='k',linewidth=2.0, label=label2)
                             ax.plotline3 = ax.plot(x[n][2,:,0,0], y, color='b',linewidth=2.0, label=label3)
                             ax.plotline4 = ax.plot(x[n][3,:,0,0], y, color='m',linewidth=2.0, label=label4)
                             ax.legend(loc='upper right')
                             ax.set_xlim(self.xmin, self.xmax)
                             self.titles.append('{}'.format(self.plot_name.upper()))
                         else:
                             if n==0:
                                 self.xlimits=[(self.xmin,self.xmax)]
                             else:
                                 self.xlimits.append((self.xmin,self.xmax))
                             ax.set_xlim(self.xmin, self.xmax)
                             ax.plotline1[0].set_data(x[n][0,:,0,0],y)
                             ax.plotline2[0].set_data(x[n][1,:,0,0],y)
                             ax.plotline3[0].set_data(x[n][2,:,0,0],y)
                             ax.plotline4[0].set_data(x[n][3,:,0,0],y)
                             self.titles.append('{}'.format(self.plot_name.upper()))
             class CrossProductsLPPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for cross products LP
                 '''
                 CODE = 'crossprodslp'
                 plot_name = 'Cross Products LP'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 2
                     self.nrows = 1
                     self.nplots = 2
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'dB'
                     self.width = 3.5*self.nplots
                     self.height = 5.5
                     self.colorbar = False
                     self.titles = []
                     self.plots_adjust.update({'wspace': .8 ,'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['crossprodslp'] = 10*numpy.log10(numpy.abs(dataOut.output_LP))
                     data['NRANGE'] = dataOut.NRANGE #This is metadata
                     data['NLAG'] = dataOut.NLAG #This is metadata
                     return data, meta
                 def plot(self):
                     NRANGE = self.data['NRANGE'][-1]
                     NLAG = self.data['NLAG'][-1]
                     x = self.data[self.CODE][:,-1,:,:]
                     self.y = self.data.yrange[0:NRANGE]
                     label_array=numpy.array(['lag '+ str(x) for x in range(NLAG)])
                     color_array=['r','k','g','b','c','m','y','orange','steelblue','purple','peru','darksalmon','grey','limegreen','olive','midnightblue']
                     for n, ax in enumerate(self.axes):
                         self.xmin=28#30
                         self.xmax=70#70
                         #self.xmin=numpy.min(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
                         #self.xmax=numpy.max(numpy.concatenate((self.x[0,:,n],self.x[1,:,n])))
                         if ax.firsttime:
                             self.autoxticks=False
                             if n == 0:
                                 self.plotline_array=numpy.zeros((2,NLAG),dtype=object)
                             for i in range(NLAG):
                                 self.plotline_array[n,i], = ax.plot(x[i,:,n], self.y, color=color_array[i],linewidth=1.0, label=label_array[i])
                             ax.legend(loc='upper right')
                             ax.set_xlim(self.xmin, self.xmax)
                             if n==0:
                                 self.titles.append('{} CH0'.format(self.plot_name.upper()))
                             if n==1:
                                 self.titles.append('{} CH1'.format(self.plot_name.upper()))
                         else:
                             for i in range(NLAG):
                                 self.plotline_array[n,i].set_data(x[i,:,n],self.y)
                             if n==0:
                                 self.titles.append('{} CH0'.format(self.plot_name.upper()))
                             if n==1:
                                 self.titles.append('{} CH1'.format(self.plot_name.upper()))
             class NoiseDPPlot(NoisePlot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for noise Double Pulse
                 '''
                 CODE = 'noise'
                 #plot_name = 'Noise'
                 #plot_type = 'scatterbuffer'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['noise'] = 10*numpy.log10(dataOut.noise_final)
                     return data, meta
             class XmitWaveformPlot(Plot):
                 '''
                 Written by R. Flores
                 '''
                 '''
                 Plot for xmit waveform
                 '''
                 CODE = 'xmit'
                 plot_name = 'Xmit Waveform'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = ''
                     self.xlabel = 'Number of Lag'
                     self.width = 5.5
                     self.height = 3.5
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                     self.titles = [self.plot_name]
                     #self.plots_adjust.update({'left': 0.17, 'right': 0.88, 'bottom': 0.1})
                     #if not self.titles:
                         #self.titles = self.data.parameters \
                             #if self.data.parameters else ['{}'.format(self.plot_name.upper())]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     y_1=numpy.arctan2(dataOut.output_LP[:,0,2].imag,dataOut.output_LP[:,0,2].real)* 180 / (numpy.pi*10)
                     y_2=numpy.abs(dataOut.output_LP[:,0,2])
                     norm=numpy.max(y_2)
                     norm=max(norm,0.1)
                     y_2=y_2/norm
                     meta['yrange'] = numpy.array([])
                     data['xmit'] = numpy.vstack((y_1,y_2))
                     data['NLAG'] = dataOut.NLAG
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     NLAG = data['NLAG']
                     x = numpy.arange(0,NLAG,1,'float32')
                     y = data['xmit']
                     self.xmin = 0
                     self.xmax = NLAG-1
                     self.ymin = -1.0
                     self.ymax = 1.0
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plotline0=ax.plot(x,y[0,:],color='blue')
                         ax.plotline1=ax.plot(x,y[1,:],color='red')
                         secax=ax.secondary_xaxis(location=0.5)
                         secax.xaxis.tick_bottom()
                         secax.tick_params( labelleft=False, labeltop=False,
                                   labelright=False, labelbottom=False)
                         self.xstep_given = 3
                         self.ystep_given = .25
                         secax.set_xticks(numpy.linspace(self.xmin, self.xmax, 6)) #only works on matplotlib.version>3.2
                     else:
                         ax.plotline0[0].set_data(x,y[0,:])
                         ax.plotline1[0].set_data(x,y[1,:])

schainpy/model/proc/clean_data.json +52 -2

             {"conditions": [
                 {"year": 2024, "doy": 47, "initial_time": [5,32], "final_time": [6,42], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 247, "initial_time": [2,0], "final_time": [5,0], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 247, "initial_time": [1,40], "final_time": [2,0], "aux_index": [ null, 26]},
                 {"year": 2024, "doy": 247, "initial_time": [0,45], "final_time": [0,45], "aux_index": [ null, 28]},
                 {"year": 2024, "doy": 246, "initial_time": [23,15], "final_time": [23,59], "aux_index": [ null, 21]},
                 {"year": 2024, "doy": 246, "initial_time": [13,55], "final_time": [23,59], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 247, "initial_time": [0,0], "final_time": [2,25], "aux_index": [ null, 22]},
                 {"year": 2024, "doy": 247, "initial_time": [3,0], "final_time": [3,0], "aux_index": [ 34, null]},
                 {"year": 2024, "doy": 247, "initial_time": [5,0], "final_time": [23,59], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 247, "initial_time": [5,0], "final_time": [11,25], "aux_index": [ 11, 13]},
                 {"year": 2024, "doy": 247, "initial_time": [5,30], "final_time": [9,50], "aux_index": [ 13, 13]},
                 {"year": 2024, "doy": 247, "initial_time": [23,15], "final_time": [23,59], "aux_index": [ null, 15]},
                 {"year": 2024, "doy": 248, "initial_time": [0,0], "final_time": [4,59], "aux_index": [ null, 13]},
                 {"year": 2024, "doy": 248, "initial_time": [0,0], "final_time": [1,50], "aux_index": [ null, 21]},
                 {"year": 2024, "doy": 248, "initial_time": [0,0], "final_time": [2,50], "aux_index": [ null, 17]},
                 {"year": 2024, "doy": 247, "initial_time": [8,5], "final_time": [8,10], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 248, "initial_time": [2,50], "final_time": [2,50], "aux_index": [ 30, null]},
                 {"year": 2024, "doy": 248, "initial_time": [3,55], "final_time": [4,0], "aux_index": [ 26, null]},
                 {"year": 2024, "doy": 247, "initial_time": [5,0], "final_time": [5,0], "aux_index": [ 18, 24]},
                 {"year": 2024, "doy": 247, "initial_time": [5,5], "final_time": [5,5], "aux_index": [ 21, 26]},
                 {"year": 2024, "doy": 247, "initial_time": [5,15], "final_time": [5,15], "aux_index": [ 19, 21]},
                 {"year": 2024, "doy": 247, "initial_time": [5,20], "final_time": [5,20], "aux_index": [ 21, 23]},
                 {"year": 2024, "doy": 247, "initial_time": [5,25], "final_time": [5,25], "aux_index": [ 21, 26]},
                 {"year": 2024, "doy": 247, "initial_time": [5,30], "final_time": [5,30], "aux_index": [ 20, 27]},
                 {"year": 2024, "doy": 247, "initial_time": [5,35], "final_time": [5,35], "aux_index": [ 22, 27]},
                 {"year": 2024, "doy": 247, "initial_time": [8,5], "final_time": [8,10], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 247, "initial_time": [15,30], "final_time": [15,30], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 248, "initial_time": [5,20], "final_time": [5,35], "aux_index": [ 20, null]},
                 {"year": 2024, "doy": 248, "initial_time": [5,40], "final_time": [5,55], "aux_index": [ 23, null]},
                 {"year": 2024, "doy": 248, "initial_time": [5,0], "final_time": [23,59], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 249, "initial_time": [0,0], "final_time": [4,59], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 248, "initial_time": [5,0], "final_time": [9,0], "aux_index": [ null, 13]},
                 {"year": 2024, "doy": 249, "initial_time": [2,0], "final_time": [2,20], "aux_index": [ null, 17]},
                 {"year": 2024, "doy": 249, "initial_time": [2,55], "final_time": [2,55], "aux_index": [ 27, null]},
                 {"year": 2024, "doy": 249, "initial_time": [3,0], "final_time": [3,5], "aux_index": [ 25, null]},
                 {"year": 2024, "doy": 249, "initial_time": [4,5], "final_time": [4,5], "aux_index": [ 23, null]},
                 {"year": 2024, "doy": 249, "initial_time": [4,10], "final_time": [4,10], "aux_index": [ 26, null]},
                 {"year": 2024, "doy": 249, "initial_time": [4,15], "final_time": [4,15], "aux_index": [ 30, null]},
                 {"year": 2024, "doy": 249, "initial_time": [0,30], "final_time": [0,40], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 249, "initial_time": [5,20], "final_time": [5,20], "aux_index": [ 22, null]},
                 {"year": 2024, "doy": 249, "initial_time": [5,25], "final_time": [5,25], "aux_index": [ 23, null]},
                 {"year": 2024, "doy": 249, "initial_time": [5,30], "final_time": [5,30], "aux_index": [ 18, 37]},
                 {"year": 2024, "doy": 249, "initial_time": [5,35], "final_time": [5,40], "aux_index": [ 18, 34]},
                 {"year": 2024, "doy": 249, "initial_time": [5,45], "final_time": [5,45], "aux_index": [ 20, 30]},
                 {"year": 2024, "doy": 249, "initial_time": [6,5], "final_time": [6,5], "aux_index": [ 24, null]},
                 {"year": 2024, "doy": 249, "initial_time": [10,5], "final_time": [10,5], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 249, "initial_time": [6,10], "final_time": [6,10], "aux_index": [ 29, null]},
                 {"year": 2024, "doy": 249, "initial_time": [6,45], "final_time": [6,45], "aux_index": [ 21, null]},
                 {"year": 2024, "doy": 249, "initial_time": [5,0], "final_time": [20,0], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 249, "initial_time": [23,10], "final_time": [23,59], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 250, "initial_time": [0,0], "final_time": [4,59], "aux_index": [ null, 13]},
                 {"year": 2024, "doy": 249, "initial_time": [5,0], "final_time": [8,50], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 250, "initial_time": [0,0], "final_time": [3,35], "aux_index": [ null, 23]},
                 {"year": 2024, "doy": 250, "initial_time": [0,0], "final_time": [0,55], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 249, "initial_time": [7,15], "final_time": [7,15], "aux_index": [ null, 14]},
                 {"year": 2024, "doy": 250, "initial_time": [3,15], "final_time": [3,35], "aux_index": [ 46, null]},
                 {"year": 2024, "doy": 250, "initial_time": [3,25], "final_time": [3,25], "aux_index": [ null, 30]},
                 {"year": 2024, "doy": 250, "initial_time": [3,30], "final_time": [3,30], "aux_index": [ null, 32]},
                 {"year": 2024, "doy": 250, "initial_time": [3,35], "final_time": [3,35], "aux_index": [ null, 34]},
                 {"year": 2024, "doy": 250, "initial_time": [3,40], "final_time": [3,40], "aux_index": [ 21, 38]},
                 {"year": 2024, "doy": 250, "initial_time": [3,45], "final_time": [3,45], "aux_index": [ 22, 37]},
                 {"year": 2024, "doy": 250, "initial_time": [1,35], "final_time": [1,35], "aux_index": [ 36, null]},
                 {"year": 2024, "doy": 250, "initial_time": [1,40], "final_time": [1,40], "aux_index": [ 32, null]},
                 {"year": 2024, "doy": 250, "initial_time": [1,45], "final_time": [1,45], "aux_index": [ 31, null]},
                 {"year": 2024, "doy": 250, "initial_time": [2,30], "final_time": [2,30], "aux_index": [ 30, null]},
                 {"year": 2024, "doy": 250, "initial_time": [2,35], "final_time": [2,35], "aux_index": [ 33, null]},
                 {"year": 2024, "doy": 250, "initial_time": [2,40], "final_time": [2,40], "aux_index": [ 27, null]},
                 {"year": 2024, "doy": 251, "initial_time": [3,0], "final_time": [3,45], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 251, "initial_time": [0,30], "final_time": [0,45], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 250, "initial_time": [5,0], "final_time": [5,0], "aux_index": [ 20, 41]},
             	{"year": 2024, "doy": 250, "initial_time": [5,5], "final_time": [5,10], "aux_index": [ 24, 37]},
             	{"year": 2024, "doy": 250, "initial_time": [5,20], "final_time": [5,25], "aux_index": [ 23, 39]},
             	{"year": 2024, "doy": 250, "initial_time": [5,30], "final_time": [5,30], "aux_index": [ 19, null]},
             	{"year": 2024, "doy": 250, "initial_time": [6,5], "final_time": [6,5], "aux_index": [ 24, null]},
             	{"year": 2024, "doy": 250, "initial_time": [6,10], "final_time": [6,10], "aux_index": [ 20, 41]},
             	{"year": 2024, "doy": 250, "initial_time": [6,15], "final_time": [6,15], "aux_index": [ 20, 39]},
             	{"year": 2024, "doy": 250, "initial_time": [6,20], "final_time": [6,20], "aux_index": [ 20, 37]},
             	{"year": 2024, "doy": 250, "initial_time": [6,25], "final_time": [6,25], "aux_index": [ 21, 29]},
             	{"year": 2024, "doy": 250, "initial_time": [6,30], "final_time": [6,30], "aux_index": [ 22, 29]},
             	{"year": 2024, "doy": 250, "initial_time": [6,45], "final_time": [6,45], "aux_index": [ 20, null]},
             	{"year": 2024, "doy": 250, "initial_time": [6,50], "final_time": [6,50], "aux_index": [ 19, 38]},
             	{"year": 2024, "doy": 250, "initial_time": [6,55], "final_time": [6,55], "aux_index": [ 23, 42]},
             	{"year": 2024, "doy": 250, "initial_time": [7,0], "final_time": [7,0], "aux_index": [ 20, null]},
             	{"year": 2024, "doy": 250, "initial_time": [7,5], "final_time": [7,5], "aux_index": [ 23, 40]},
             	{"year": 2024, "doy": 250, "initial_time": [7,10], "final_time": [7,10], "aux_index": [ 23, 42]},
             	{"year": 2024, "doy": 250, "initial_time": [7,15], "final_time": [7,15], "aux_index": [ 25, 37]},
             	{"year": 2024, "doy": 250, "initial_time": [7,30], "final_time": [7,30], "aux_index": [ 25, 40]},
             	{"year": 2024, "doy": 250, "initial_time": [7,35], "final_time": [7,35], "aux_index": [ 25, 39]},
             	{"year": 2024, "doy": 250, "initial_time": [7,40], "final_time": [7,40], "aux_index": [ 23, 41]},
             	{"year": 2024, "doy": 250, "initial_time": [7,45], "final_time": [7,45], "aux_index": [ 27, 38]},
                 {"year": 2024, "doy": 250, "initial_time": [23,10], "final_time": [23,59], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 251, "initial_time": [0,0], "final_time": [4,59], "aux_index": [ null, 13]},
                 {"year": 2024, "doy": 250, "initial_time": [5,0], "final_time": [8,10], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 250, "initial_time": [9,10], "final_time": [10,50], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 251, "initial_time": [0,0], "final_time": [3,30], "aux_index": [ null, 27]},
                 {"year": 2024, "doy": 250, "initial_time": [19,30], "final_time": [19,30], "aux_index": [ 19, 26]},
                 {"year": 2024, "doy": 250, "initial_time": [10,50], "final_time": [13,20], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 251, "initial_time": [5,0], "final_time": [5,0], "aux_index": [ 23, 40]},
                 {"year": 2024, "doy": 251, "initial_time": [5,5], "final_time": [5,10], "aux_index": [ 25, 40]},
                 {"year": 2024, "doy": 251, "initial_time": [17,30], "final_time": [20,30], "aux_index": [ 56, null]},
                 {"year": 2024, "doy": 251, "initial_time": [5,0], "final_time": [8,10], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 251, "initial_time": [5,0], "final_time": [20,0], "aux_index": [ null, 11]},
                 {"year": 2024, "doy": 251, "initial_time": [19,50], "final_time": [19,50], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 252, "initial_time": [0,30], "final_time": [0,55], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 252, "initial_time": [0,55], "final_time": [1,0], "aux_index": [ null, 40]},
                 {"year": 2024, "doy": 252, "initial_time": [1,0], "final_time": [1,15], "aux_index": [ null, 34]},
                 {"year": 2024, "doy": 252, "initial_time": [0,30], "final_time": [0,55], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 252, "initial_time": [1,35], "final_time": [1,55], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 251, "initial_time": [23,10], "final_time": [23,59], "aux_index": [ null, 20]},
                 {"year": 2024, "doy": 252, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 252, "initial_time": [0,0], "final_time": [1,50], "aux_index": [ null, 31]},
                 {"year": 2024, "doy": 252, "initial_time": [3,20], "final_time": [3,25], "aux_index": [ 22, null]},
                 {"year": 2024, "doy": 252, "initial_time": [3,30], "final_time": [3,35], "aux_index": [ 23, null]},
                 {"year": 2024, "doy": 252, "initial_time": [3,50], "final_time": [3,50], "aux_index": [ 22, null]},
                 {"year": 2024, "doy": 252, "initial_time": [3,55], "final_time": [4,5], "aux_index": [ 21, null]},
                 {"year": 2024, "doy": 252, "initial_time": [4,10], "final_time": [4,10], "aux_index": [ 21, 36]},
                 {"year": 2024, "doy": 252, "initial_time": [5,0], "final_time": [20,0], "aux_index": [ null, 12]},
                 {"year": 2024, "doy": 252, "initial_time": [13,0], "final_time": [13,0], "aux_index": [ null, null]},
                 {"year": 2024, "doy": 252, "initial_time": [5,15], "final_time": [5,20], "aux_index": [ 23, null]},
                 {"year": 2024, "doy": 252, "initial_time": [5,25], "final_time": [5,25], "aux_index": [ 27, 36]},
                 {"year": 2024, "doy": 252, "initial_time": [5,30], "final_time": [5,30], "aux_index": [ 27, null]},
                 {"year": 2024, "doy": 252, "initial_time": [5,35], "final_time": [5,35], "aux_index": [ 31, null]},
                 {"year": 2024, "doy": 252, "initial_time": [5,20], "final_time": [5,40], "aux_index": [ 33, null]},
                 {"year": 2024, "doy": 252, "initial_time": [7,5], "final_time": [7,5], "aux_index": [ 21, null]},
                 {"year": 2024, "doy": 252, "initial_time": [7,10], "final_time": [7,10], "aux_index": [ 23, null]},
                 {"year": 2025, "doy": 21, "initial_time": [19,45], "final_time": [19,50], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 22, "initial_time": [0,50], "final_time": [3,30], "aux_index": [ null, 30]},
                 {"year": 2025, "doy": 22, "initial_time": [1,50], "final_time": [1,50], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 22, "initial_time": [2,15], "final_time": [2,25], "aux_index": [ null, 38]},
                 {"year": 2025, "doy": 22, "initial_time": [2,25], "final_time": [2,35], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 22, "initial_time": [2,40], "final_time": [2,50], "aux_index": [ null, 40]},
                 {"year": 2025, "doy": 22, "initial_time": [2,40], "final_time": [2,40], "aux_index": [ 44, null]},
                 {"year": 2025, "doy": 22, "initial_time": [2,45], "final_time": [2,45], "aux_index": [ 50, null]},
                 {"year": 2025, "doy": 22, "initial_time": [3,0], "final_time": [3,15], "aux_index": [ null, 33]},
                 {"year": 2025, "doy": 22, "initial_time": [3,30], "final_time": [4,15], "aux_index": [ null, 28]},
                 {"year": 2025, "doy": 22, "initial_time": [4,15], "final_time": [4,25], "aux_index": [ null, 24]},
                 {"year": 2025, "doy": 22, "initial_time": [3,50], "final_time": [4,15], "aux_index": [ null, 15]},
                 {"year": 2025, "doy": 22, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 22, "initial_time": [5,0], "final_time": [23,55], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 22, "initial_time": [14,20], "final_time": [14,20], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 23, "initial_time": [0,10], "final_time": [0,10], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 23, "initial_time": [0,55], "final_time": [3,30], "aux_index": [ null, 26]},
                 {"year": 2025, "doy": 23, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 23, "initial_time": [2,25], "final_time": [2,25], "aux_index": [ null, 34]},
                 {"year": 2025, "doy": 23, "initial_time": [2,10], "final_time": [2,10], "aux_index": [ 44, 48]},
                 {"year": 2025, "doy": 23, "initial_time": [0,50], "final_time": [0,50], "aux_index": [ 53, 53]},
                 {"year": 2025, "doy": 23, "initial_time": [5,0], "final_time": [23,55], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 23, "initial_time": [5,0], "final_time": [8,0], "aux_index": [ null, 14]},
                 {"year": 2025, "doy": 23, "initial_time": [12,5], "final_time": [12,5], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 24, "initial_time": [1,40], "final_time": [3,15], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 24, "initial_time": [3,25], "final_time": [3,30], "aux_index": [ 44, null]},
                 {"year": 2025, "doy": 24, "initial_time": [3,20], "final_time": [3,40], "aux_index": [ null, 31]},
                 {"year": 2025, "doy": 24, "initial_time": [3,40], "final_time": [4,55], "aux_index": [ null, 29]},
                 {"year": 2025, "doy": 24, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 24, "initial_time": [5,0], "final_time": [23,55], "aux_index": [ null, 13]},
-                {"year": 2025, "doy": 25, "initial_time": [0,0], "final_time": [4,55], "aux_index": [ null, 27]},
+                {"year": 2025, "doy": 24, "initial_time": [5,0], "final_time": [5,5], "aux_index": [ null, 34]},
+                {"year": 2025, "doy": 24, "initial_time": [5,10], "final_time": [5,10], "aux_index": [ 24, 35]},
+                {"year": 2025, "doy": 24, "initial_time": [5,15], "final_time": [5,15], "aux_index": [ 25, 33]},
+                {"year": 2025, "doy": 24, "initial_time": [5,20], "final_time": [5,20], "aux_index": [ 26, 33]},
+                {"year": 2025, "doy": 24, "initial_time": [5,25], "final_time": [5,25], "aux_index": [ 27, 32]},
+                {"year": 2025, "doy": 24, "initial_time": [5,30], "final_time": [5,30], "aux_index": [ 23, 24]},
+                {"year": 2025, "doy": 24, "initial_time": [5,35], "final_time": [5,35], "aux_index": [ 22, 27]},
+                {"year": 2025, "doy": 24, "initial_time": [5,40], "final_time": [5,55], "aux_index": [ 22, 31]},
+                {"year": 2025, "doy": 24, "initial_time": [6,0], "final_time": [6,0], "aux_index": [ 22, 33]},
+                {"year": 2025, "doy": 24, "initial_time": [6,30], "final_time": [6,30], "aux_index": [ 22, 25]},
+                {"year": 2025, "doy": 24, "initial_time": [6,35], "final_time": [6,35], "aux_index": [ 22, 32]},
+                {"year": 2025, "doy": 24, "initial_time": [6,35], "final_time": [6,40], "aux_index": [ 22, 32]},
+                {"year": 2025, "doy": 24, "initial_time": [6,45], "final_time": [6,45], "aux_index": [ 23, 32]},
+                {"year": 2025, "doy": 24, "initial_time": [6,50], "final_time": [6,50], "aux_index": [ 24, 34]},
+                {"year": 2025, "doy": 24, "initial_time": [6,55], "final_time": [6,55], "aux_index": [ 25, 32]},
+                {"year": 2025, "doy": 25, "initial_time": [0,50], "final_time": [4,55], "aux_index": [ null, 27]},
                 {"year": 2025, "doy": 25, "initial_time": [2,50], "final_time": [4,55], "aux_index": [ null, 30]},
+                {"year": 2025, "doy": 25, "initial_time": [3,5], "final_time": [3,45], "aux_index": [ null, 33]},
                 {"year": 2025, "doy": 25, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 25, "initial_time": [5,0], "final_time": [23,55], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 26, "initial_time": [2,50], "final_time": [4,5], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 26, "initial_time": [2,50], "final_time": [4,5], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 26, "initial_time": [0,40], "final_time": [4,20], "aux_index": [ null, 24]},
                 {"year": 2025, "doy": 26, "initial_time": [4,30], "final_time": [4,30], "aux_index": [ null, 20]},
                 {"year": 2025, "doy": 26, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
                 {"year": 2025, "doy": 26, "initial_time": [5,0], "final_time": [23,55], "aux_index": [ null, 13]},
+                {"year": 2025, "doy": 26, "initial_time": [5,20], "final_time": [5,20], "aux_index": [ null, 28]},
+                {"year": 2025, "doy": 26, "initial_time": [5,25], "final_time": [5,25], "aux_index": [ 25, 34]},
                 {"year": 2025, "doy": 26, "initial_time": [0,55], "final_time": [0,55], "aux_index": [ null, null]},
                 {"year": 2025, "doy": 26, "initial_time": [0,55], "final_time": [4,55], "aux_index": [ null, 24]},
-                {"year": 2025, "doy": 27, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]}
+                {"year": 2025, "doy": 27, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 13]},
+                {"year": 2025, "doy": 41, "initial_time": [23,0], "final_time": [23,0], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 42, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 14]},
+                {"year": 2025, "doy": 42, "initial_time": [4,24], "final_time": [4,24], "aux_index": [ 35, 38]},
+                {"year": 2025, "doy": 42, "initial_time": [1,30], "final_time": [5,0], "aux_index": [ null, 26]},
+                {"year": 2025, "doy": 42, "initial_time": [2,12], "final_time": [4,0], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 42, "initial_time": [1,24], "final_time": [1,24], "aux_index": [ 39, 40]},
+                {"year": 2025, "doy": 42, "initial_time": [1,18], "final_time": [1,18], "aux_index": [ 48, 50]},
+                {"year": 2025, "doy": 42, "initial_time": [5,0], "final_time": [12,0], "aux_index": [ null, 7]},
+                {"year": 2025, "doy": 42, "initial_time": [5,0], "final_time": [7,30], "aux_index": [ null, 13]},
+                {"year": 2025, "doy": 42, "initial_time": [5,0], "final_time": [11,0], "aux_index": [ null, 10]},
+                {"year": 2025, "doy": 42, "initial_time": [5,0], "final_time": [5,0], "aux_index": [ 20, 22]},
+                {"year": 2025, "doy": 43, "initial_time": [0,0], "final_time": [5,0], "aux_index": [ null, 19]},
+                {"year": 2025, "doy": 43, "initial_time": [2,25], "final_time": [2,38], "aux_index": [ null, 24]},
+                {"year": 2025, "doy": 43, "initial_time": [2,2], "final_time": [2,2], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 43, "initial_time": [5,0], "final_time": [10,50], "aux_index": [ null, 12]},
+                {"year": 2025, "doy": 43, "initial_time": [5,0], "final_time": [23,0], "aux_index": [ null, 8]},
+                {"year": 2025, "doy": 44, "initial_time": [0,50], "final_time": [0,50], "aux_index": [ 47, null]},
+                {"year": 2025, "doy": 44, "initial_time": [1,0], "final_time": [1,15], "aux_index": [ 39, null]},
+                {"year": 2025, "doy": 44, "initial_time": [3,14], "final_time": [3,40], "aux_index": [ null, 30]},
+                {"year": 2025, "doy": 44, "initial_time": [3,26], "final_time": [3,26], "aux_index": [ null, 32]},
+                {"year": 2025, "doy": 44, "initial_time": [0,14], "final_time": [3,40], "aux_index": [ null, 22]},
+                {"year": 2025, "doy": 44, "initial_time": [0,40], "final_time": [3,40], "aux_index": [ null, 25]},
+                {"year": 2025, "doy": 44, "initial_time": [4,0], "final_time": [5,0], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 44, "initial_time": [5,50], "final_time": [5,50], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 44, "initial_time": [7,50], "final_time": [8,38], "aux_index": [ null, null]},
+                {"year": 2025, "doy": 44, "initial_time": [5,0], "final_time": [9,14], "aux_index": [ null, 14]}
             ]}

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

schainpy/model/proc/jroproc_spectra_lags_faraday.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

schainpy/model/proc/jroproc_voltage.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

schainpy/model/proc/jroproc_voltage_lags.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

schainpy/model/proc/normalize_factor2.json 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