schain Commit - r1394:99588b4ace71 · Jicamarca Repository

valid en jroproc_parameters

avaldez -

r1394:99588b4ace71

parent child

Context file:

r1394:99588b4ace71

Collapse all files

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

schainpy/model/graphics/jroplot_parameters.py +10 -2

             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             # libreria wradlib
             import wradlib as wrl
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DobleGaussianPlot(SpectraPlot):
                 '''
                 Plot for Double Gaussian Plot
                 '''
                 CODE = 'gaussian_fit'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
                 '''
                 Plot SpectraCut with Double Gaussian Fit
                 '''
                 CODE = 'cut_gaussian_fit'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'snr': 10*numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'dop': 10*numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
                     }
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'width': dataOut.data_width
                     }
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Range [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = 10*numpy.log10(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())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class WeatherPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     self.colorbar=False
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_azi   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(250.0))
+                    if hasattr(dataOut, 'dataPP_POWER'):
+                        factor = 1
+                    if hasattr(dataOut, 'nFFTPoints'):
+                        factor = dataOut.normFactor
+                    print("factor",factor)
+                    data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(factor))
+                    print("weather",data['weather'])
                     data['azi']     = dataOut.data_azi
                     return data, meta
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     if self.ini==0:
                         #------- AZIMUTH
                         n     = (360/res)-len(data_azi)
                         start = data_azi[-1] + res
                         end   = data_azi[0]  - res
                         if start>end:
                             end        = end + 360
                         azi_vacia = numpy.linspace(start,end,int(n))
                         azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
                         data_azi  = numpy.hstack((data_azi,azi_vacia))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,0])
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
                         start = data_azi[0]
                         end   = data_azi[-1]
                         print("start",start)
                         print("end",end)
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
                         print("start",start)
                         print("end",end)
                         #### AQUI SERA LA MAGIA
                         pos_ini = int((start-start_azi)/res)
                         len_azi = len(data_azi)
                         if (360-pos_ini)<len_azi:
                             if pos_ini+1==360:
                                 pos_ini=0
                             else:
                                 flag=1
                                 dif= 360-pos_ini
                                 comp= len_azi-dif
                         print(pos_ini)
                         print(len_azi)
                         print("shape",self.res_azi.shape)
                         if flag==0:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
                         else:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
                             self.res_azi[0:comp]              = data_azi[dif:]
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
                             self.res_weather[0:comp,:]              = data_weather[dif:,:]
                             flag=0
                         data_azi                                    = self.res_azi
                         data_weather                                = self.res_weather
                     return data_weather,data_azi
                 def plot(self):
                     print("--------------------------------------",self.ini,"-----------------------------------")
                     #numpy.set_printoptions(suppress=True)
                     #print(self.data.times)
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
                     data         = self.data[-1]
                     # ALTURA altura_tmp_h
                     altura_h     = (data['weather'].shape[1])/10.0
                     stoprange = float(altura_h*1.5)#stoprange = float(33*1.5) por ahora 400
                     rangestep = float(0.15)
                     r      = numpy.arange(0, stoprange, rangestep)
                     self.y = 2*r
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res     = 1
                     # STEP
                     step    = (360/(res*data['weather'].shape[0]))
                     #print("shape wr_data", wr_data.shape)
                     #print("shape wr_azi",wr_azi.shape)
                     #print("step",step)
                     print("Time---->",self.data.times[-1],thisDatetime)
                     #print("alturas", len(self.y))
                     self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'],data_azi=data['azi'],step=step,res=res)
                     #numpy.set_printoptions(suppress=True)
                     #print("resultado",self.res_azi)
                     ##########################################################
                     #################    PLOTEO           ###################
                     ##########################################################
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             plt.clf()
                             cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
                         else:
                             plt.clf()
-                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=0, vmax=60)
+                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
                     caax = cgax.parasites[0]
                     paax = cgax.parasites[1]
                     cbar = plt.gcf().colorbar(pm, pad=0.075)
                     caax.set_xlabel('x_range [km]')
                     caax.set_ylabel('y_range [km]')
                     plt.text(1.0, 1.05, 'azimuth '+str(thisDatetime)+"step"+str(self.ini), transform=caax.transAxes, va='bottom',ha='right')
                     self.ini= self.ini+1

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.py +22 -22

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Spectra processing Unit and operations
             Here you will find the processing unit `SpectraProc` and several operations
             to work with Spectra data type
             """
             import time
             import itertools
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, MPDecorator, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
             from schainpy.utils import log
             class SpectraProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                     self.id_min = None
                     self.id_max = None
                     self.setupReq = False #Agregar a todas las unidades de proc
                 def __updateSpecFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     try:
                         self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
                     except:
                         pass
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.realtime = self.dataIn.realtime
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                     """
                     fft_volt = numpy.fft.fft(
                         self.buffer, n=self.dataOut.nFFTPoints, axis=1)
                     fft_volt = fft_volt.astype(numpy.dtype('complex'))
                     dc = fft_volt[:, 0, :]
                     # calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt, axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         # calculo de cross-spectra
                         cspc = numpy.zeros(
                             (self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
                                 raise ValueError("Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
                                     str(pair), str(self.dataOut.channelList)))
                             if pair[1] not in self.dataOut.channelList:
                                 raise ValueError("Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
                                     str(pair), str(self.dataOut.channelList)))
                             cspc[pairIndex, :, :] = fft_volt[pair[0], :, :] * \
                                 numpy.conjugate(fft_volt[pair[1], :, :])
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc = spc
                     self.dataOut.data_cspc = cspc
                     self.dataOut.data_dc = dc
                     self.dataOut.blockSize = blocksize
                     self.dataOut.flagShiftFFT = False
                 def run(self, nProfiles=None, nFFTPoints=None, pairsList=None, ippFactor=None, shift_fft=False):
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
                         if shift_fft:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             shift = int(self.dataOut.nFFTPoints/2)
                             self.dataOut.data_spc = numpy.roll(self.dataOut.data_spc, shift , axis=1)
                             if self.dataOut.data_cspc is not None:
                                 #desplaza a la derecha en el eje 2 determinadas posiciones
                                 self.dataOut.data_cspc = numpy.roll(self.dataOut.data_cspc, shift, axis=1)
                         if pairsList:
                             self.__selectPairs(pairsList)
                     elif self.dataIn.type == "Voltage":
                         self.dataOut.flagNoData = True
                         if nFFTPoints == None:
                             raise ValueError("This SpectraProc.run() need nFFTPoints input variable")
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                         if ippFactor == None:
                             self.dataOut.ippFactor = 1
                         self.dataOut.nFFTPoints = nFFTPoints
                         if self.buffer is None:
                             self.buffer = numpy.zeros((self.dataIn.nChannels,
                                                        nProfiles,
                                                        self.dataIn.nHeights),
                                                       dtype='complex')
                         if self.dataIn.flagDataAsBlock:
                             nVoltProfiles = self.dataIn.data.shape[1]
                             if nVoltProfiles == nProfiles:
                                 self.buffer = self.dataIn.data.copy()
                                 self.profIndex = nVoltProfiles
                             elif nVoltProfiles < nProfiles:
                                 if self.profIndex == 0:
                                     self.id_min = 0
                                     self.id_max = nVoltProfiles
                                 self.buffer[:, self.id_min:self.id_max,
                                             :] = self.dataIn.data
                                 self.profIndex += nVoltProfiles
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
                                 raise ValueError("The type object %s has %d profiles, it should just has %d profiles" % (
                                     self.dataIn.type, self.dataIn.data.shape[1], nProfiles))
                                 self.dataOut.flagNoData = True
                         else:
                             self.buffer[:, self.profIndex, :] = self.dataIn.data.copy()
                             self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == nProfiles:
                             self.__updateSpecFromVoltage()
                             if pairsList == None:
                                 self.dataOut.pairsList = [pair for pair in itertools.combinations(self.dataOut.channelList, 2)]
                             else:
                                 self.dataOut.pairsList = pairsList
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
                     else:
                         raise ValueError("The type of input object '%s' is not valid".format(
                             self.dataIn.type))
                 def __selectPairs(self, pairsList):
                     if not pairsList:
                         return
                     pairs = []
                     pairsIndex = []
                     for pair in pairsList:
                         if pair[0] not in self.dataOut.channelList or pair[1] not in self.dataOut.channelList:
                             continue
                         pairs.append(pair)
                         pairsIndex.append(pairs.index(pair))
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
                     self.dataOut.pairsList = pairs
                     return
                 def selectFFTs(self, minFFT, maxFFT ):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de puntos FFTs segun el rango
                     minFFT<= FFT <= maxFFT
                     """
                     if (minFFT > maxFFT):
                         raise ValueError("Error selecting heights: Height range (%d,%d) is not valid" % (minFFT, maxFFT))
                     if (minFFT < self.dataOut.getFreqRange()[0]):
                         minFFT = self.dataOut.getFreqRange()[0]
                     if (maxFFT > self.dataOut.getFreqRange()[-1]):
                         maxFFT = self.dataOut.getFreqRange()[-1]
                     minIndex = 0
                     maxIndex = 0
                     FFTs = self.dataOut.getFreqRange()
                     inda = numpy.where(FFTs >= minFFT)
                     indb = numpy.where(FFTs <= maxFFT)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(FFTs)
                     self.selectFFTsByIndex(minIndex, maxIndex)
                     return 1
                 def getBeaconSignal(self, tauindex=0, channelindex=0, hei_ref=None):
                     newheis = numpy.where(
                         self.dataOut.heightList > self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                     if hei_ref != None:
                         newheis = numpy.where(self.dataOut.heightList > hei_ref)
                     minIndex = min(newheis[0])
                     maxIndex = max(newheis[0])
                     data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
                     heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     # determina indices
                     nheis = int(self.dataOut.radarControllerHeaderObj.txB /
                                 (self.dataOut.heightList[1] - self.dataOut.heightList[0]))
                     avg_dB = 10 * \
                         numpy.log10(numpy.sum(data_spc[channelindex, :, :], axis=0))
                     beacon_dB = numpy.sort(avg_dB)[-nheis:]
                     beacon_heiIndexList = []
                     for val in avg_dB.tolist():
                         if val >= beacon_dB[0]:
                             beacon_heiIndexList.append(avg_dB.tolist().index(val))
                     #data_spc = data_spc[:,:,beacon_heiIndexList]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
                         #data_cspc = data_cspc[:,:,beacon_heiIndexList]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
                         #data_dc = data_dc[:,beacon_heiIndexList]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = heightList
                     self.dataOut.beacon_heiIndexList = beacon_heiIndexList
                     return 1
                 def selectFFTsByIndex(self, minIndex, maxIndex):
                     """
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nProfiles):
                         maxIndex = self.dataOut.nProfiles-1
                     #Spectra
                     data_spc = self.dataOut.data_spc[:,minIndex:maxIndex+1,:]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,minIndex:maxIndex+1,:]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[minIndex:maxIndex+1,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.ippSeconds = self.dataOut.ippSeconds*(self.dataOut.nFFTPoints / numpy.shape(data_cspc)[1])
                     self.dataOut.nFFTPoints = numpy.shape(data_cspc)[1]
                     self.dataOut.profilesPerBlock = numpy.shape(data_cspc)[1]
                     return 1
                 def getNoise(self, minHei=None, maxHei=None, minVel=None, maxVel=None):
                     # validacion de rango
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                     if maxHei == None:
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                         print('minHei: %.2f is out of the heights range' % (minHei))
                         print('minHei is setting to %.2f' % (self.dataOut.heightList[0]))
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
                         print('maxHei: %.2f is out of the heights range' % (maxHei))
                         print('maxHei is setting to %.2f' % (self.dataOut.heightList[-1]))
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                     velrange = self.dataOut.getVelRange(1)
                     if minVel == None:
                         minVel = velrange[0]
                     if maxVel == None:
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
                         print('minVel: %.2f is out of the velocity range' % (minVel))
                         print('minVel is setting to %.2f' % (velrange[0]))
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
                         print('maxVel: %.2f is out of the velocity range' % (maxVel))
                         print('maxVel is setting to %.2f' % (velrange[-1]))
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError("some value in (%d,%d) is not valid" % (
                             minIndex, maxIndex))
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights - 1
                     # seleccion de indices para velocidades
                     indminvel = numpy.where(velrange >= minVel)
                     indmaxvel = numpy.where(velrange <= maxVel)
                     try:
                         minIndexVel = indminvel[0][0]
                     except:
                         minIndexVel = 0
                     try:
                         maxIndexVel = indmaxvel[0][-1]
                     except:
                         maxIndexVel = len(velrange)
                     # seleccion del espectro
                     data_spc = self.dataOut.data_spc[:,
                                                      minIndexVel:maxIndexVel + 1, minIndex:maxIndex + 1]
                     # estimacion de ruido
                     noise = numpy.zeros(self.dataOut.nChannels)
                     for channel in range(self.dataOut.nChannels):
                         daux = data_spc[channel, :, :]
                         sortdata = numpy.sort(daux, axis=None)
                         noise[channel] = hildebrand_sekhon(sortdata, self.dataOut.nIncohInt)
                     self.dataOut.noise_estimation = noise.copy()
                     return 1
             class removeDC(Operation):
                 def run(self, dataOut, mode=2):
                     self.dataOut = dataOut
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     if jcspectra is not None:
                         jcspectraExist = True
                         num_pairs = jcspectra.shape[0]
                     else:
                         jcspectraExist = False
                     freq_dc = int(jspectra.shape[1] / 2)
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     ind_vel = ind_vel.astype(int)
                     if ind_vel[0] < 0:
                         ind_vel[list(range(0, 1))] = ind_vel[list(range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                             jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                         if jcspectraExist:
                             jcspectra[:, freq_dc, :] = (
                                 jcspectra[:, ind_vel[1], :] + jcspectra[:, ind_vel[2], :]) / 2
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
                             xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
                             junkid = jspectra[ich, freq_dc, :] <= 0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich, freq_dc, junkid.nonzero()] = (
                                     jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                         if jcspectraExist:
                             for ip in range(num_pairs):
                                 yy = jcspectra[ip, ind_vel, :]
                                 jcspectra[ip, freq_dc, :] = numpy.dot(xx_aux, yy)
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return self.dataOut
             class removeInterference(Operation):
                 def removeInterference2(self):
                     cspc = self.dataOut.data_cspc
                     spc = self.dataOut.data_spc
                     Heights = numpy.arange(cspc.shape[2])
                     realCspc = numpy.abs(cspc)
                     for i in range(cspc.shape[0]):
                         LinePower= numpy.sum(realCspc[i], axis=0)
                         Threshold = numpy.amax(LinePower)-numpy.sort(LinePower)[len(Heights)-int(len(Heights)*0.1)]
                         SelectedHeights = Heights[ numpy.where( LinePower < Threshold ) ]
                         InterferenceSum = numpy.sum( realCspc[i,:,SelectedHeights], axis=0 )
                         InterferenceThresholdMin = numpy.sort(InterferenceSum)[int(len(InterferenceSum)*0.98)]
                         InterferenceThresholdMax = numpy.sort(InterferenceSum)[int(len(InterferenceSum)*0.99)]
                         InterferenceRange = numpy.where( ([InterferenceSum > InterferenceThresholdMin]))# , InterferenceSum < InterferenceThresholdMax]) )
                         #InterferenceRange = numpy.where( ([InterferenceRange < InterferenceThresholdMax]))
                         if len(InterferenceRange)<int(cspc.shape[1]*0.3):
                             cspc[i,InterferenceRange,:] = numpy.NaN
                     self.dataOut.data_cspc = cspc
                 def removeInterference(self, interf = 2, hei_interf = None, nhei_interf = None, offhei_interf = None):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     jnoise = self.dataOut.getNoise()
                     num_incoh = self.dataOut.nIncohInt
                     num_channel = jspectra.shape[0]
                     num_prof = jspectra.shape[1]
                     num_hei = jspectra.shape[2]
                     # hei_interf
                     if hei_interf is None:
                         count_hei = int(num_hei / 2)
                         hei_interf = numpy.asmatrix(list(range(count_hei))) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     # nhei_interf
                     if (nhei_interf == None):
                         nhei_interf = 5
                     if (nhei_interf < 1):
                         nhei_interf = 1
                     if (nhei_interf > count_hei):
                         nhei_interf = count_hei
                     if (offhei_interf == None):
                         offhei_interf = 0
                     ind_hei = list(range(num_hei))
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
                     mask_prof = numpy.asarray(list(range(num_prof)))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof / 2]
                     # noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
                     if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
                         jnoise = numpy.nan
                     noise_exist = jnoise[0] < numpy.Inf
                     # Subrutina de Remocion de la Interferencia
                     for ich in range(num_channel):
                         # Se ordena los espectros segun su potencia (menor a mayor)
                         power = jspectra[ich, mask_prof, :]
                         power = power[:, hei_interf]
                         power = power.sum(axis=0)
                         psort = power.ravel().argsort()
                         # Se estima la interferencia promedio en los Espectros de Potencia empleando
                         junkspc_interf = jspectra[ich, :, hei_interf[psort[list(range(
                             offhei_interf, nhei_interf + offhei_interf))]]]
                         if noise_exist:
                             #    tmp_noise = jnoise[ich] / num_prof
                             tmp_noise = jnoise[ich]
                         junkspc_interf = junkspc_interf - tmp_noise
                         #junkspc_interf[:,comp_mask_prof] = 0
                         jspc_interf = junkspc_interf.sum(axis=0) / nhei_interf
                         jspc_interf = jspc_interf.transpose()
                         # Calculando el espectro de interferencia promedio
                         noiseid = numpy.where(
                             jspc_interf <= tmp_noise / numpy.sqrt(num_incoh))
                         noiseid = noiseid[0]
                         cnoiseid = noiseid.size
                         interfid = numpy.where(
                             jspc_interf > tmp_noise / numpy.sqrt(num_incoh))
                         interfid = interfid[0]
                         cinterfid = interfid.size
                         if (cnoiseid > 0):
                             jspc_interf[noiseid] = 0
                         # Expandiendo los perfiles a limpiar
                         if (cinterfid > 0):
                             new_interfid = (
                                 numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof) % num_prof
                             new_interfid = numpy.asarray(new_interfid)
                             new_interfid = {x for x in new_interfid}
                             new_interfid = numpy.array(list(new_interfid))
                             new_cinterfid = new_interfid.size
                         else:
                             new_cinterfid = 0
                         for ip in range(new_cinterfid):
                             ind = junkspc_interf[:, new_interfid[ip]].ravel().argsort()
                             jspc_interf[new_interfid[ip]
                                         ] = junkspc_interf[ind[nhei_interf // 2], new_interfid[ip]]
                         jspectra[ich, :, ind_hei] = jspectra[ich, :,
                                                              ind_hei] - jspc_interf  # Corregir indices
                         # Removiendo la interferencia del punto de mayor interferencia
                         ListAux = jspc_interf[mask_prof].tolist()
                         maxid = ListAux.index(max(ListAux))
                         if cinterfid > 0:
                             for ip in range(cinterfid * (interf == 2) - 1):
                                 ind = (jspectra[ich, interfid[ip], :] < tmp_noise *
                                        (1 + 1 / numpy.sqrt(num_incoh))).nonzero()
                                 cind = len(ind)
                                 if (cind > 0):
                                     jspectra[ich, interfid[ip], ind] = tmp_noise * \
                                         (1 + (numpy.random.uniform(cind) - 0.5) /
                                          numpy.sqrt(num_incoh))
                             ind = numpy.array([-2, -1, 1, 2])
                             xx = numpy.zeros([4, 4])
                             for id1 in range(4):
                                 xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:, 0]
                             ind = (ind + maxid + num_mask_prof) % num_mask_prof
                             yy = jspectra[ich, mask_prof[ind], :]
                             jspectra[ich, mask_prof[maxid], :] = numpy.dot(
                                 yy.transpose(), xx)
                         indAux = (jspectra[ich, :, :] < tmp_noise *
                                   (1 - 1 / numpy.sqrt(num_incoh))).nonzero()
                         jspectra[ich, indAux[0], indAux[1]] = tmp_noise * \
                             (1 - 1 / numpy.sqrt(num_incoh))
                     # Remocion de Interferencia en el Cross Spectra
                     if jcspectra is None:
                         return jspectra, jcspectra
                     num_pairs = int(jcspectra.size / (num_prof * num_hei))
                     jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
                     for ip in range(num_pairs):
                         #-------------------------------------------
                         cspower = numpy.abs(jcspectra[ip, mask_prof, :])
                         cspower = cspower[:, hei_interf]
                         cspower = cspower.sum(axis=0)
                         cspsort = cspower.ravel().argsort()
                         junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[list(range(
                             offhei_interf, nhei_interf + offhei_interf))]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
                         median_real = int(numpy.median(numpy.real(
                             junkcspc_interf[mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
                         median_imag = int(numpy.median(numpy.imag(
                             junkcspc_interf[mask_prof[ind[list(range(3 * num_prof // 4))]], :])))
                         comp_mask_prof = [int(e) for e in comp_mask_prof]
                         junkcspc_interf[comp_mask_prof, :] = numpy.complex(
                             median_real, median_imag)
                         for iprof in range(num_prof):
                             ind = numpy.abs(junkcspc_interf[iprof, :]).ravel().argsort()
                             jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf // 2]]
                         # Removiendo la Interferencia
                         jcspectra[ip, :, ind_hei] = jcspectra[ip,
                                                               :, ind_hei] - jcspc_interf
                         ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
                         maxid = ListAux.index(max(ListAux))
                         ind = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for id1 in range(4):
                             xx[:, id1] = ind[id1]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:, 0]
                         ind = (ind + maxid + num_mask_prof) % num_mask_prof
                         yy = jcspectra[ip, mask_prof[ind], :]
                         jcspectra[ip, mask_prof[maxid], :] = numpy.dot(yy.transpose(), xx)
                     # Guardar Resultados
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def run(self, dataOut, interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None, mode=1):
                     self.dataOut = dataOut
                     if mode == 1:
                         self.removeInterference(interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None)
                     elif mode == 2:
                         self.removeInterference2()
                     return self.dataOut
             class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer_spc = None
                 __buffer_cspc = None
                 __buffer_dc = None
                 __dataReady = False
                 __timeInterval = None
                 n = None
                 def __init__(self):
                     Operation.__init__(self)
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     self.__dataReady = False
                     self.__byTime = False
                     if n is None and timeInterval is None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n is not None:
                         self.n = int(n)
                     else:
                         self.__integrationtime = int(timeInterval)
                         self.n = None
                         self.__byTime = True
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                     """
                     self.__buffer_spc += data_spc
                     if data_cspc is None:
                         self.__buffer_cspc = None
                     else:
                         self.__buffer_cspc += data_cspc
                     if data_dc is None:
                         self.__buffer_dc = None
                     else:
                         self.__buffer_dc += data_dc
                     self.__profIndex += 1
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     data_spc = self.__buffer_spc
                     data_cspc = self.__buffer_cspc
                     data_dc = self.__buffer_dc
                     n = self.__profIndex
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if self.__profIndex == self.n:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def byTime(self, datatime, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def integrate(self, datatime, *args):
                     if self.__profIndex == 0:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(
                             datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                     if not self.__dataReady:
                         return None, None, None, None
                     return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if n == 1:
                         return dataOut
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.isConfig = True
                     avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                         dataOut.data_spc,
                                                                                         dataOut.data_cspc,
                                                                                         dataOut.data_dc)
                     if self.__dataReady:
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False
                     return dataOut
             class dopplerFlip(Operation):
                 def run(self, dataOut):
                     # arreglo 1: (num_chan, num_profiles, num_heights)
                     self.dataOut = dataOut
                     # JULIA-oblicua, indice 2
                     # arreglo 2: (num_profiles, num_heights)
                     jspectra = self.dataOut.data_spc[2]
                     jspectra_tmp = numpy.zeros(jspectra.shape)
                     num_profiles = jspectra.shape[0]
                     freq_dc = int(num_profiles / 2)
                     # Flip con for
                     for j in range(num_profiles):
                         jspectra_tmp[num_profiles-j-1]= jspectra[j]
                     # Intercambio perfil de DC con perfil inmediato anterior
                     jspectra_tmp[freq_dc-1]= jspectra[freq_dc-1]
                     jspectra_tmp[freq_dc]= jspectra[freq_dc]
                     # canal modificado es re-escrito en el arreglo de canales
                     self.dataOut.data_spc[2] = jspectra_tmp
-                    return self.dataOut
  No newline at end of file
+                    return self.dataOut

schainpy/scripts/basic_proc00001.py +3 -3

             # Ing. AVP
             # 06/10/2021
             # ARCHIVO DE LECTURA
             import os, sys
             import datetime
             import time
             from schainpy.controller import Project
             #### NOTA###########################################
             # INPUT :
             # VELOCIDAD PARAMETRO :        V = 2°/seg
             # MODO PULSE PAIR O MOMENTOS:  0 : Pulse Pair ,1 : Momentos
             ######################################################
             ##### PROCESAMIENTO ##################################
             #####  OJO TENER EN CUENTA EL n= para el Pulse Pair ##
             #####                   O EL n= nFFTPoints         ###
             ######################################################
             ######## BUSCAMOS EL numero de IPP equivalente 1°#####
             ######## Sea V la velocidad del Pedestal en °/seg#####
             ######## 1° sera Recorrido en un tiempo de  1/V ######
             ######## IPP del Radar 400 useg --> 60 Km ############
             ######## n   = 1/(V(°/seg)*IPP(Km)) , NUMERO DE IPP ##
             ######## n   = 1/(V*IPP) #############################
             ######## VELOCIDAD DEL PEDESTAL ######################
             print("SETUP- RADAR METEOROLOGICO")
             V       = 10
             mode    = 1
             #path    = '/DATA_RM/23/6v'
             ####path    = '/DATA_RM/TEST_INTEGRACION_2M'
             #path    = '/DATA_RM/TEST_19OCTUBRE/10MHZ'
             path    = '/DATA_RM/WR_20_OCT'
             #### path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
-            #### path_ped='/DATA_RM/TEST_PEDESTAL/P20211019-192244'
+            ####path_ped='/DATA_RM/TEST_PEDESTAL/P20211019-192244'
             figpath_pp  = "/home/soporte/Pictures/TEST_PP"
             figpath_spec = "/home/soporte/Pictures/TEST_MOM"
-            plot        = 1
+            plot        = 0
-            integration = 0
+            integration = 1
             save        = 0
             if save == 1:
                 if mode==0:
                     path_save = '/DATA_RM/TEST_HDF5_PP_23/6v'
                     path_save = '/DATA_RM/TEST_HDF5_PP'
                     path_save = '/DATA_RM/TEST_HDF5_PP_100'
                 else:
                     path_save = '/DATA_RM/TEST_HDF5_SPEC_23_V2/6v'
             print("* PATH data ADQ        :", path)
             print("* Velocidad Pedestal   :",V,"°/seg")
             ############################ NRO Perfiles PROCESAMIENTO ###################
             V=V
             IPP=400*1e-6
             n= int(1/(V*IPP))
             print("* n - NRO Perfiles Proc:", n )
             ################################## MODE ###################################
             print("* Modo de Operacion    :",mode)
             if mode ==0:
                 print("* Met. Seleccionado    : Pulse Pair")
             else:
                 print("* Met. Momentos        : Momentos")
             ################################## MODE ###################################
             print("* Grabado de datos     :",save)
             if save ==1:
                 if mode==0:
                     ope= "Pulse Pair"
                 else:
                     ope= "Momentos"
                 print("* Path-Save Data -", ope , path_save)
             print("* Integracion de datos :",integration)
             time.sleep(15)
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             dBmin = '1'
             dBmax = '65'
             xmin = '13.2'
             xmax = '13.5'
             ymin = '0'
             ymax = '60'
             #######################################################################
             ########################FECHA##########################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ########################SIGNAL CHAIN ##################################
             #######################################################################
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
                                                         startDate="2021/01/01",#today,
                                                         endDate="2021/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             if mode ==0:
                 ####################### METODO PULSE PAIR ######################################################################
                 opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
                 opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
                 #opObj11.addParameter(name='removeDC', value=1, format='int')
                 ####################### METODO Parametros ######################################################################
                 procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
                 if plot==1:
                     opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
                     opObj11.addParameter(name='attr_data', value='dataPP_POWER')
                     opObj11.addParameter(name='colormap', value='jet')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_pp)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=10)
                 ####################### METODO ESCRITURA #######################################################################
                 if save==1:
                     opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='100',format='int')
                     opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
                     opObj10.addParameter(name='dataList',value='dataPP_POWER,dataPP_DOP,utctime',format='list')#,format='list'
                 if integration==1:
                     V=10
                     blocksPerfile=360
                     print("* Velocidad del Pedestal:",V)
                     tmp_blocksPerfile = 100
                     f_a_p= int(tmp_blocksPerfile/V)
                     opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation')
                     opObj11.addParameter(name='path_ped', value=path_ped)
                     #opObj11.addParameter(name='path_adq', value=path_adq)
                     opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
                     opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
                     opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                     opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                     opObj11.addParameter(name='online', value='0', format='int')
                     opObj11 = procUnitConfObjB.addOperation(name='Block360')
                     opObj11.addParameter(name='n', value='10', format='int')
                     opObj11.addParameter(name='mode', value=mode, format='int')
                     # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                     opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
             else:
                 ####################### METODO SPECTROS ######################################################################
                 procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
                 procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
                 procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
                 procUnitConfObjC = controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
                 procUnitConfObjC.addOperation(name='SpectralMoments')
                 if plot==1:
                     dBmin = '1'
                     dBmax = '65'
                     opObj11 = procUnitConfObjC.addOperation(name='PowerPlot',optype='external')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_spec)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=10)
                 if save==1:
                     opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='360',format='int')
                     #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
                 if integration==1:
                    V=10
                    blocksPerfile=360
                    print("* Velocidad del Pedestal:",V)
                    tmp_blocksPerfile = 100
                    f_a_p= int(tmp_blocksPerfile/V)
                    opObj11 = procUnitConfObjC.addOperation(name='PedestalInformation')
                    opObj11.addParameter(name='path_ped', value=path_ped)
                    #opObj11.addParameter(name='path_adq', value=path_adq)
                    opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
                    opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
                    opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                    opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                    opObj11.addParameter(name='online', value='0', format='int')
                    opObj11 = procUnitConfObjC.addOperation(name='Block360')
                    opObj11.addParameter(name='n', value='10', format='int')
                    opObj11.addParameter(name='mode', value=mode, format='int')
                    # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                    opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
             controllerObj.start()

schainpy/scripts/basic_proc00002.py +2 -2

             # Ing. AVP
             # 06/10/2021
             # ARCHIVO DE LECTURA
             import os, sys
             import datetime
             import time
             from schainpy.controller import Project
             #### NOTA###########################################
             # INPUT :
             # VELOCIDAD PARAMETRO :        V = 2°/seg
             # MODO PULSE PAIR O MOMENTOS:  0 : Pulse Pair ,1 : Momentos
             ######################################################
             ##### PROCESAMIENTO ##################################
             #####  OJO TENER EN CUENTA EL n= para el Pulse Pair ##
             #####                   O EL n= nFFTPoints         ###
             ######################################################
             ######## BUSCAMOS EL numero de IPP equivalente 1°#####
             ######## Sea V la velocidad del Pedestal en °/seg#####
             ######## 1° sera Recorrido en un tiempo de  1/V ######
             ######## IPP del Radar 400 useg --> 60 Km ############
             ######## n   = 1/(V(°/seg)*IPP(Km)) , NUMERO DE IPP ##
             ######## n   = 1/(V*IPP) #############################
             ######## VELOCIDAD DEL PEDESTAL ######################
             print("SETUP- RADAR METEOROLOGICO")
             V       = 10
             mode    = 1
             #path    = '/DATA_RM/23/6v'
             #path    = '/DATA_RM/TEST_INTEGRACION_2M'
             path    = '/DATA_RM/WR_20_OCT'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
             path_ped='/DATA_RM/TEST_PEDESTAL/P20211020-131248'
             figpath_pp  = "/home/soporte/Pictures/TEST_PP"
             figpath_mom = "/home/soporte/Pictures/TEST_MOM"
             plot        = 0
             integration = 1
             save        = 0
             if save == 1:
                 if mode==0:
                     path_save = '/DATA_RM/TEST_HDF5_PP_23/6v'
                     path_save = '/DATA_RM/TEST_HDF5_PP'
                     path_save = '/DATA_RM/TEST_HDF5_PP_100'
                 else:
                     path_save = '/DATA_RM/TEST_HDF5_SPEC_23_V2/6v'
             print("* PATH data ADQ        :", path)
             print("* Velocidad Pedestal   :",V,"°/seg")
             ############################ NRO Perfiles PROCESAMIENTO ###################
             V=V
             IPP=400*1e-6
             n= int(1/(V*IPP))
             print("* n - NRO Perfiles Proc:", n )
             ################################## MODE ###################################
             print("* Modo de Operacion    :",mode)
             if mode ==0:
                 print("* Met. Seleccionado    : Pulse Pair")
             else:
                 print("* Met. Momentos        : Momentos")
             ################################## MODE ###################################
             print("* Grabado de datos     :",save)
             if save ==1:
                 if mode==0:
                     ope= "Pulse Pair"
                 else:
                     ope= "Momentos"
                 print("* Path-Save Data -", ope , path_save)
             print("* Integracion de datos :",integration)
-            time.sleep(15)
+            time.sleep(5)
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             dBmin = '1'
             dBmax = '85'
             xmin = '15'
             xmax = '15.25'
             ymin = '0'
             ymax = '600'
             #######################################################################
             ########################FECHA##########################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ########################SIGNAL CHAIN ##################################
             #######################################################################
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
                                                         startDate="2021/01/01",#today,
                                                         endDate="2021/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             if mode ==0:
                 ####################### METODO PULSE PAIR ######################################################################
                 opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
                 opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
                 #opObj11.addParameter(name='removeDC', value=1, format='int')
                 ####################### METODO Parametros ######################################################################
                 procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
                 if plot==1:
                     opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
                     opObj11.addParameter(name='attr_data', value='dataPP_POW')
                     opObj11.addParameter(name='colormap', value='jet')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_pp)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=50)
                 ####################### METODO ESCRITURA #######################################################################
                 if save==1:
                     opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='100',format='int')
                     opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
                     opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
                 if integration==1:
                     V=10
                     blocksPerfile=360
                     print("* Velocidad del Pedestal:",V)
                     tmp_blocksPerfile = 100
                     f_a_p= int(tmp_blocksPerfile/V)
                     opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation')
                     opObj11.addParameter(name='path_ped', value=path_ped)
                     #opObj11.addParameter(name='path_adq', value=path_adq)
                     opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
                     opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
                     opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                     opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                     opObj11.addParameter(name='online', value='0', format='int')
                     opObj11 = procUnitConfObjB.addOperation(name='Block360')
                     opObj11.addParameter(name='n', value='10', format='int')
                     opObj11.addParameter(name='mode', value=mode, format='int')
                     # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                     opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
             else:
                 ####################### METODO SPECTROS ######################################################################
                 procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
                 procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
                 procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
                 procUnitConfObjC = controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
                 procUnitConfObjC.addOperation(name='SpectralMoments')
                 if plot==1:
                     dBmin = '1'
                     dBmax = '65'
                     opObj11 = procUnitConfObjC.addOperation(name='PowerPlot',optype='external')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_mom)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=100)
                 if save==1:
                     opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='360',format='int')
                     #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
                 if integration==1:
                    V=10
                    blocksPerfile=360
                    print("* Velocidad del Pedestal:",V)
                    tmp_blocksPerfile = 100
                    f_a_p= int(tmp_blocksPerfile/V)
                    opObj11 = procUnitConfObjC.addOperation(name='PedestalInformation')
                    opObj11.addParameter(name='path_ped', value=path_ped)
                    #opObj11.addParameter(name='path_adq', value=path_adq)
                    opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
                    opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
                    opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                    opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                    opObj11.addParameter(name='online', value='0', format='int')
                    opObj11 = procUnitConfObjC.addOperation(name='Block360')
-                   opObj11.addParameter(name='n', value='30', format='int')
+                   opObj11.addParameter(name='n', value='10', format='int')
                    opObj11.addParameter(name='mode', value=mode, format='int')
                    # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                    opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
             controllerObj.start()

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