schain Commit - r1429:96f17ea26f9f · Jicamarca Repository

update

avaldezp -

r1429:96f17ea26f9f

parent child

Context file:

r1429:96f17ea26f9f

Collapse all files

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

schainpy/model/graphics/jroplot_parameters.py +128 -68

             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
                     self.last_data_azi = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
                     data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         diff_ = angulos[i]-angulos[i-1]
                         if diff_ >1.5:
                             list1.append(i-1)
                             list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData360(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+360
                         return ang_
                     return ang_
                 def fixData360HL(self,angulos):
                     vec = numpy.where(angulos>=360)
                     angulos[vec]=angulos[vec]-360
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(list2_[i])-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(list2_[value])-1):
                                 ang_new[pos+k]  = ang_new[pos+k-1]+1
                                 ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos):
                     l1,l2 = self.get2List(angulos)
                     if len(l1)>0:
                         angulos2 = self.fixData360(list_=l1,ang_=angulos)
                         l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
                         ang1_ = self.fixData360HL(ang1_)
                         ang2_ = self.fixData360HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def analizeDATA(self,data_azi):
                     list1 = []
                     list2 = []
                     dat   = data_azi
                     for i in reversed(range(1,len(dat))):
                         if dat[i]>dat[i-1]:
                             diff = int(dat[i])-int(dat[i-1])
                         else:
                             diff = 360+int(dat[i])-int(dat[i-1])
                         if diff > 1:
                             list1.append(i-1)
                             list2.append(diff-1)
                     return list1,list2
                 def fixDATANEW(self,data_azi,data_weather):
                     list1,list2 = self.analizeDATA(data_azi)
                     if len(list1)== 0:
                         return data_azi,data_weather
                     else:
                         resize = 0
                         for i in range(len(list2)):
                             resize=  resize + list2[i]
                         new_data_azi = numpy.resize(data_azi,resize)
                         new_data_weather= numpy.resize(date_weather,resize)
                         for i in range(len(list2)):
                             j=0
                             position=list1[i]+1
                             for j in range(list2[i]):
                                 new_data_azi[position+j]=new_data_azi[position+j-1]+1
                     return new_data_azi
                 def fixDATA(self,data_azi):
                     data=data_azi
                     for i in range(len(data)):
                         if numpy.isnan(data[i]):
                            data[i]=data[i-1]+1
                     return data
                 def replaceNAN(self,data_weather,data_azi,val):
                     data= data_azi
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 sc=c+1
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     if self.ini==0:
                         #-------
                         n     = (360/res)-len(data_azi)
                         #--------------------- new -------------------------
                         data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
                         #------------------------
                         start = data_azi_new[-1] + res
                         end   = data_azi_new[0]  - res
                         #------ new
                         self.last_data_azi = end
                         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_new,azi_vacia))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
                         #-----------new------------
                         data_azi ,data_azi_old= self.globalCheckPED(data_azi)
                         data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         #--------------------------
                         start = data_azi[0]
                         end   = data_azi[-1]
                         self.last_data_azi= end
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
                         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
                         #-----------------
                         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):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res          = 1
                     # STEP
                     step         = (360/(res*data['weather'].shape[0]))
                     self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
                     self.res_ele = numpy.mean(data['ele'])
                     #################    PLOTEO           ###################
                     print("self.axes",self.axes)
                     for i,ax in enumerate(self.axes):
                         print("INDICE:     ",i)
                         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=20, vmax=80)
                         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=20, vmax=80)
                     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)+ " Elev: "+str(round(self.res_ele,2)), transform=caax.transAxes, va='bottom',ha='right')
                     self.ini= self.ini+1
             class WeatherRHIPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'rhistyle'
                 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_ele   = 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
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
-                        diff_ = angulos[i]-angulos[i-1]
+                        if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
-                        if diff_ >1.5:
+                            diff_ = angulos[i]-angulos[i-1]
-                            list1.append(i-1)
+                            if abs(diff_) >1.5:
-                            list2.append(diff_)
+                                list1.append(i-1)
+                                list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
-                def fixData180(self,list_,ang_):
+                def fixData90(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
-                        ang_[vec] = ang_[vec]+180
+                        ang_[vec] = ang_[vec]+90
                         return ang_
                     return ang_
-                def fixData180HL(self,angulos):
+                def fixData90HL(self,angulos):
-                    vec = numpy.where(angulos>=180)
+                    vec = numpy.where(angulos>=90)
-                    angulos[vec]=angulos[vec]-180
+                    angulos[vec]=angulos[vec]-90
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
-                def fixDataComp(self,ang_,list1_,list2_):
+                def fixDataComp(self,ang_,list1_,list2_,tipo_case):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
-                        size2=size2+round(list2_[i])-1
+                        size2=size2+round(abs(list2_[i]))-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
-                            for k in range(round(list2_[value])-1):
+                            for k in range(round(abs(list2_[value]))-1):
-                                ang_new[pos+k]  = ang_new[pos+k-1]+1
+                                if tipo_case==0 or tipo_case==3:#subida
-                                ang_new2[pos+k] = numpy.nan
+                                    ang_new[pos+k]  = ang_new[pos+k-1]+1
+                                    ang_new2[pos+k] = numpy.nan
+                                elif tipo_case==1 or tipo_case==2:#bajada
+                                    ang_new[pos+k]  = ang_new[pos+k-1]-1
+                                    ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
-                def globalCheckPED(self,angulos):
+                def globalCheckPED(self,angulos,tipo_case):
                     l1,l2 = self.get2List(angulos)
+                    print("l1",l1)
+                    print("l2",l2)
                     if len(l1)>0:
-                        angulos2 = self.fixData180(list_=l1,ang_=angulos)
+                        #angulos2 = self.fixData90(list_=l1,ang_=angulos)
-                        l1,l2 = self.get2List(angulos2)
+                        #l1,l2 = self.get2List(angulos2)
+                        ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
-                        ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
+                        #ang1_ = self.fixData90HL(ang1_)
-                        ang1_ = self.fixData180HL(ang1_)
+                        #ang2_ = self.fixData90HL(ang2_)
-                        ang2_ = self.fixData180HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def replaceNAN(self,data_weather,data_ele,val):
                     data= data_ele
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 sc=c+1
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
-                def const_ploteo(self,data_weather,data_ele,step,res):
+                def check_case(self,data_ele,ang_max,ang_min):
+                    start  = data_ele[0]
+                    end    = data_ele[-1]
+                    number = (end-start)
+                    len_ang=len(data_ele)
+                    if start<end and round(abs(number)+1)>=len_ang:#caso subida
+                        return 0
+                    elif start>end and round(abs(number)+1)>=len_ang:#caso bajada
+                        return 1
+                    elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
+                        return 2
+                    elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1]:# caso SUBIDA CAMBIO ANG MIN
+                        return 3
+                def const_ploteo(self,data_weather,data_ele,step,res,ang_max,ang_min):
+                    ang_max= ang_max
+                    ang_min= ang_min
                     if self.ini==0:
-                        #-------
+                        print("**********************************************")
-                        n     = (180/res)-len(data_ele)
+                        print("**********************************************")
+                        print("***************ini**************")
+                        print("**********************************************")
+                        print("**********************************************")
+                        print("data_ele",data_ele)
+                        #----------------------------------------------------------
+                        tipo_case = self.check_case(data_ele,ang_max,ang_min)
+                        print("TIPO DE DATA",tipo_case)
                         #--------------------- new -------------------------
-                        data_ele_new ,data_ele_old= self.globalCheckPED(data_ele)
+                        data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
-                        #------------------------
+                        print("data_ele_new",data_ele_new)
-                        start = data_ele_new[-1] + res
+                        print("data_ele_old",data_ele_old)
-                        end   = data_ele_new[0]  - res
+                        #-------------------------CAMBIOS RHI---------------------------------
+                        start= ang_min
+                        end  = ang_min
+                        n= (ang_max-ang_min)/res
                         #------ new
-                        self.last_data_ele = end
+                        self.start_data_ele = data_ele_new[0]
-                        if start>end:
+                        self.end_data_ele  = data_ele_new[-1]
-                            end        = end + 180
+                        if tipo_case==0  or tipo_case==3:
+                            n1= round(self.start_data_ele)- start
+                            n2= end - round(self.end_data_ele)
+                            if n1>0:
+                                ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
+                                ele1_nan= numpy.ones(n1)*numpy.nan
+                                data_ele = numpy.hstack((ele1,data_ele_new))
+                                data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
+                            if n2>0:
+                                ele2= numpy.linspace(self.end_data_ele+1,end,n2)
+                                ele2_nan= numpy.ones(n2)*numpy.nan
+                                data_ele = numpy.hstack((data_ele,ele2))
+                                data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
+                            # RADAR
+                            val_mean         = numpy.mean(data_weather[:,-1])
+                            self.val_mean    = val_mean
+                            data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
+                        '''
                         ele_vacia = numpy.linspace(start,end,int(n))
-                        ele_vacia = numpy.where(ele_vacia>180,ele_vacia-180,ele_vacia)
+                        ele_vacia = numpy.where(ele_vacia>ang_max,ele_vacia-ang_max,ele_vacia)
                         data_ele  = numpy.hstack((data_ele_new,ele_vacia))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
-                        data_weather_cmp = numpy.ones([(180-data_weather.shape[0]),data_weather.shape[1]])*val_mean
+                        data_weather_cmp = numpy.ones([(ang_max-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
+                        '''
                     else:
-                        # azimuth
+                        print("**********************************************")
+                        print("**********************************************")
+                        print("****************VARIABLE**********************")
+                        print("**********************************************")
+                        print("**********************************************")
+                        #-------------------------CAMBIOS RHI---------------------------------
+                        #---------------------------------------------------------------------
+                        print("INPUT data_ele",data_ele)
                         flag=0
                         start_ele = self.res_ele[0]
+                        tipo_case = self.check_case(data_ele,ang_max,ang_min)
+                        print("TIPO DE DATA",tipo_case)
                         #-----------new------------
-                        data_ele ,data_ele_old= self.globalCheckPED(data_ele)
+                        data_ele ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
+                        print("data_ele_new",data_ele)
+                        print("data_ele_old",data_ele_old)
                         data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
+                        '''
                         #--------------------------
                         start = data_ele[0]
                         end   = data_ele[-1]
                         self.last_data_ele= end
                         if start< start_ele:
-                            start = start +180
+                            start = start +ang_max
                         if end <start_ele:
-                            end  = end +180
+                            end  = end +ang_max
                         pos_ini = int((start-start_ele)/res)
                         len_ele = len(data_ele)
-                        if (180-pos_ini)<len_ele:
+                        if (ang_max-pos_ini)<len_ele:
-                            if pos_ini+1==180:
+                            if pos_ini+1==ang_max:
                                 pos_ini=0
                             else:
                                 flag=1
-                                dif= 180-pos_ini
+                                dif= ang_max-pos_ini
                                 comp= len_ele-dif
                         #-----------------
                         if flag==0:
                             # elevacion
                             self.res_ele[pos_ini:pos_ini+len_ele] = data_ele
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+len_ele,:] = data_weather
                         else:
                             # elevacion
                             self.res_ele[pos_ini:pos_ini+dif] = data_ele[0:dif]
                             self.res_ele[0:comp]              = data_ele[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_ele                                    = self.res_ele
                         data_weather                                = self.res_weather
+                        '''
+                        print("OUPUT data_ele",data_ele)
                     return data_weather,data_ele
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
+                    res          = 1
+                    print("data['weather'].shape[0]",data['weather'].shape[0])
+                    ang_max = 80
+                    ang_min = 0
+                    var_ang      =ang_max -  ang_min
+                    step         = (int(var_ang)/(res*data['weather'].shape[0]))
+                    print("step",step)
                     '''
                     #-------------------------------------------------------------
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res          = 1
                     # STEP
                     step = (180/(res*data['weather'].shape[0]))
                     self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res)
                     self.res_azi = numpy.mean(data['azi'])
                     print("self.res_ele------------------------------:",self.res_ele)
-                    #################    PLOTEO           ###################
-                    for i,ax in enumerate(self.axes):
-                        if ax.firsttime:
-                            plt.clf()
-                            cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
-                        else:
-                            plt.clf()
-                            cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
-                    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, 'Elevacion '+str(thisDatetime)+"  Step   "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
-                    self.ini= self.ini+1
                     '''
                     #--------------------------------------------------------
+                    print('weather',data['weather'].shape)
+                    print('ele',data['ele'].shape)
-                    ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['ele'],step=step,res=res)
+                    self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
-                    ###self.res_azi                   = numpy.mean(data['azi'])
+                    self.res_azi                   = numpy.mean(data['azi'])
+                    print("self.res_ele",self.res_ele)
                     #-------------
                     # 90 angulos en el axis 0
                     # 1000 step en el axis 1
-                    self.res_weather = numpy.ones([120,1000])
+                    ###self.res_weather = numpy.ones([120,1000])
-                    r                = numpy.linspace(0,1999,1000)
+                    ###r                = numpy.linspace(0,1999,1000)
-                    self.res_ele     = numpy.arange(0,120)
+                    ###self.res_ele     = numpy.arange(0,120)
-                    self.res_azi     = 240
+                    ###self.res_azi     = 240
                     #-------------
+                    '''
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             plt.clf()
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg')
                         else:
                             plt.clf()
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather,r=r,th=self.res_ele,fig=self.figures[0], proj='cg')
                     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, 'Elevacion '+str(thisDatetime)+"  Step   "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
+                    '''
+                    print("""""""""""""self.ini""""""""""""",self.ini)
                     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/scripts/USRP_PLOT_THOR.py +1 -1

             #!python
             '''
             '''
             import os, sys
             import datetime
             import time
             #path = os.path.dirname(os.getcwd())
             #path = os.path.dirname(path)
             #sys.path.insert(0, path)
             from schainpy.controller import Project
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
             #######################################################################
             ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
             #######################################################################
             #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman'
             #path = '/DATA_RM/TEST_INTEGRACION'
             #path = '/DATA_RM/TEST_ONLINE'
             #path ="/DATA_RM/TEST_LU_21_10M/NOISE_LNA_ON_TX_OFF"
             #path ="/DATA_RM/TEST_LU_21_10M/NOISE_LNA_OFF_TX_OFF"
             path = "/DATA_RM/TEST_MARTES_22_4M_1us"
             figpath = '/home/soporte/Pictures/TEST_MAR_22_4M_1us'
             #path = "/DATA_RM/TEST_MARTES_22_2M_1us"
             #figpath = '/home/soporte/Pictures/TEST_MAR_22_2M_1us'
             #path = "/DATA_RM/TEST_MARTES_22_1M_1us"
             #figpath = '/home/soporte/Pictures/TEST_MAR_22_1M_1us'
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
             dBmin = '20'
             dBmax = '80'
             xmin = '16'
             xmax ='18'
             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")
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
                                                         startDate="2022/03/22",#today,
                                                         endDate="2022/03/22",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
             #######################################################################
             ################ OPERACIONES DOMINIO DEL TIEMPO########################
             #######################################################################
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             #
             # codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\
             #              '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1'
             #opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
             #opObj11.addParameter(name='frequency', value='70312500')
             opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
             opObj11.addParameter(name='minIndex', value='1', format='int')
             #    opObj11.addParameter(name='maxIndex', value='10000', format='int')
             opObj11.addParameter(name='maxIndex', value='200', format='int')
             '''
             opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
             opObj11.addParameter(name='n', value='625', format='int')#10
             opObj11.addParameter(name='removeDC', value=1, format='int')
             '''
             # Ploteo TEST
             '''
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
             #opObj11.addParameter(name='xmax', value=8)
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
             '''
             # OJO SCOPE
             #opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
             #opObj10.addParameter(name='id', value='10', format='int')
             ##opObj10.addParameter(name='xmin', value='0', format='int')
             ##opObj10.addParameter(name='xmax', value='50', format='int')
             #opObj10.addParameter(name='type', value='iq')
             ##opObj10.addParameter(name='ymin', value='-5000', format='int')
             ##opObj10.addParameter(name='ymax', value='8500', format='int')
             #opObj11.addParameter(name='save', value=figpath, format='str')
             #opObj11.addParameter(name='save_period', value=10, format='int')
             #opObj10 = procUnitConfObjA.addOperation(name='setH0')
             #opObj10.addParameter(name='h0', value='-5000', format='float')
             #opObj11 =  procUnitConfObjA.addOperation(name='filterByHeights')
             #opObj11.addParameter(name='window', value='1', format='int')
             #codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1'
             #opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
             #opObj11.addParameter(name='code', value=codigo, format='floatlist')
             #opObj11.addParameter(name='nCode', value='1', format='int')
             #opObj11.addParameter(name='nBaud', value='28', format='int')
             #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
             #opObj11.addParameter(name='n', value='100', format='int')
             #######################################################################
             ########## OPERACIONES ParametersProc########################
             #######################################################################
             ###procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
             '''
             opObj11 = procUnitConfObjA.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='n_Muestras_p', value='100', format='float')
             opObj11.addParameter(name='blocksPerfile', value='100', format='int')
             opObj11.addParameter(name='f_a_p', value='25', format='int')
             opObj11.addParameter(name='online', value='0', format='int')
             opObj11 = procUnitConfObjA.addOperation(name='Block360')
             opObj11.addParameter(name='n', value='40', format='int')
             opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
             opObj11.addParameter(name='save', value=figpath)
             opObj11.addParameter(name='save_period', value=1)
             '''
             #######################################################################
             ########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
             #######################################################################
             procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
-            procUnitConfObjB.addParameter(name='nFFTPoints', value='250', format='int')
+            procUnitConfObjB.addParameter(name='nFFTPoints', value='0', format='int')
             procUnitConfObjB.addParameter(name='nProfiles', value='250', format='int')
             #procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
             #procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int')
             #procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int')
             #opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
             #opObj11.addParameter(name='timeInterval', value='8', format='int')
             #procUnitConfObjB.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList')
             #opObj13 = procUnitConfObjB.addOperation(name='removeDC')
             #opObj13.addParameter(name='mode', value='2', format='int')
             #opObj11 = procUnitConfObjB.addOperation(name='IncohInt', optype='other')
             #opObj11.addParameter(name='n', value='8', format='float')
             #######################################################################
             ########## PLOTEO DOMINIO DE LA FRECUENCIA#############################
             #######################################################################
             #----
             """
             opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
             opObj11.addParameter(name='id', value='10', format='int')
             opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
             #opObj11.addParameter(name='xmin', value=-100000, format='float')
             #opObj11.addParameter(name='xmax', value=100000, format='float')
             #opObj11.addParameter(name='zmin', value=dBmin, format='int')
             #opObj11.addParameter(name='zmax', value=dBmax, format='int')
             opObj11.addParameter(name='ymin', value=-20, format='int')
             opObj11.addParameter(name='ymax', value=50, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
             """
             #SpectraPlot
             opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
             opObj11.addParameter(name='id', value='1', format='int')
             opObj11.addParameter(name='wintitle', value='Spectra', format='str')
             #opObj11.addParameter(name='xmin', value=-0.01, format='float')
             #opObj11.addParameter(name='xmax', value=0.01, format='float')
             opObj11.addParameter(name='zmin', value=dBmin, format='int')
             opObj11.addParameter(name='zmax', value=dBmax, format='int')
             #opObj11.addParameter(name='ymin', value=ymin, format='int')
             #opObj11.addParameter(name='ymax', value=ymax, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
             #RTIPLOT
             opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external')
             opObj11.addParameter(name='id', value='2', format='int')
             opObj11.addParameter(name='wintitle', value='RTIPlot', format='str')
             opObj11.addParameter(name='zmin', value=dBmin, format='int')
             opObj11.addParameter(name='zmax', value=dBmax, format='int')
             #opObj11.addParameter(name='ymin', value=ymin, format='int')
             #opObj11.addParameter(name='ymax', value=ymax, format='int')
             opObj11.addParameter(name='xmin', value=xmin, format='int')
             opObj11.addParameter(name='xmax', value=xmax, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
             # opObj11 = procUnitConfObjB.addOperation(name='CrossSpectraPlot', optype='other')
             # opObj11.addParameter(name='id', value='3', format='int')
             # opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
             # opObj11.addParameter(name='ymin', value=ymin, format='int')
             # opObj11.addParameter(name='ymax', value=ymax, format='int')
             # opObj11.addParameter(name='phase_cmap', value='jet', format='str')
             # opObj11.addParameter(name='zmin', value=dBmin, format='int')
             # opObj11.addParameter(name='zmax', value=dBmax, format='int')
             # opObj11.addParameter(name='figpath', value=figures_path, format='str')
             # opObj11.addParameter(name='save', value=0, format='bool')
             # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
             # #
             # opObj11 = procUnitConfObjB.addOperation(name='CoherenceMap', optype='other')
             # opObj11.addParameter(name='id', value='4', format='int')
             # opObj11.addParameter(name='wintitle', value='Coherence', format='str')
             # opObj11.addParameter(name='phase_cmap', value='jet', format='str')
             # opObj11.addParameter(name='xmin', value=xmin, format='float')
             # opObj11.addParameter(name='xmax', value=xmax, format='float')
             # opObj11.addParameter(name='figpath', value=figures_path, format='str')
             # opObj11.addParameter(name='save', value=0, format='bool')
             # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
             #
             '''
             #######################################################################
             ############### UNIDAD DE ESCRITURA ###################################
             #######################################################################
             #opObj11 = procUnitConfObjB.addOperation(name='SpectraWriter', optype='other')
             #opObj11.addParameter(name='path', value=wr_path)
             #opObj11.addParameter(name='blocksPerFile', value='50', format='int')
             print ("Escribiendo el archivo XML")
             print ("Leyendo el archivo XML")
             '''
             controllerObj.start()

schainpy/scripts/check_pedestal.py +3 -2

             # Ing-AlexanderValdez
             # Monitoreo de Pedestal
             ############## IMPORTA LIBRERIAS ###################
             import os,numpy,h5py
             import sys,time
             import matplotlib.pyplot as plt
             ####################################################
             #################################################################
             # LA FECHA 21-10-20 CORRESPONDE A LAS PRUEBAS DEL DIA MIERCOLES
             # 1:15:51 pm hasta 3:49:32 pm
             #################################################################
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211012-082745'
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211020-131248'
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211110-171003'
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173856'
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211123-143826'
             #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220217-172216"
             #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-163824"
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173409'
             #--------------------------------
             path_ped= "/DATA_RM/TEST_PEDESTAL/P20220401-172744"
             # Metodo para verificar numero
             def isNumber(str):
                 try:
                     float(str)
                     return True
                 except:
                     return False
             # Metodo para extraer el arreglo
             def getDatavaluefromDirFilename(path,file,value):
                 dir_file= path+"/"+file
                 fp      = h5py.File(dir_file,'r')
                 array    = fp['Data'].get(value)[()]
                 fp.close()
                 return array
             # LISTA COMPLETA DE ARCHIVOS HDF5 Pedestal
             LIST= sorted(os.listdir(path_ped))
             m=len(LIST)
             print("TOTAL DE ARCHIVOS DE PEDESTAL:",m)
             # Contadores temporales
             k=  0
             l=  0
             t=  0
             # Marca de tiempo temporal
             time_        = numpy.zeros([m])
             # creacion de
             for i in range(m):
                 print("order:",i)
                 tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_pos")
                 tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_pos")
                 tmp_azi_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel")
                 tmp_ele_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_vel")# nuevo :D
                 time_[i]    = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="utc")
                 k=k +tmp_azi_pos.shape[0]
                 l=l +tmp_ele_pos.shape[0]
                 t=t +tmp_azi_vel.shape[0]
             print("TOTAL DE MUESTRAS, ARCHIVOS X100:",k)
             time.sleep(5)
             ######CREACION DE ARREGLOS CANTIDAD DE VALORES POR MUESTRA#################
             azi_pos     = numpy.zeros([k])
             ele_pos     = numpy.zeros([l])
             time_azi_pos= numpy.zeros([k])
             # Contadores temporales
             p=0
             r=0
             z=0
             # VARIABLES TMP para almacenar azimuth, elevacion y tiempo
             #for filename in sorted(os.listdir(path_ped)):
             # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
             for filename in LIST:
-                tmp_azi_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos")
+                #tmp_azi_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos")
                 tmp_ele_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_pos")
-                #tmp_azi_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_vel")
+                tmp_azi_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_vel")
                 #tmp_ele_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_vel")
                 # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
                 if z==(m-1):
                     tmp_azi_time=numpy.arange(time_[z],time_[z]+1,1/(tmp_azi_pos.shape[0]))
                 else:
                     tmp_azi_time=numpy.arange(time_[z],time_[z+1],(time_[z+1]-time_[z])/(tmp_azi_pos.shape[0]))
                 print(filename,time_[z])
                 print(z,tmp_azi_pos.shape[0])
                 i=0
                 for i in range(tmp_azi_pos.shape[0]):
                     index=p+i
                     azi_pos[index]=tmp_azi_pos[i]
                     time_azi_pos[index]=tmp_azi_time[i]
                 p=p+tmp_azi_pos.shape[0]
                 i=0
                 for i in range(tmp_ele_pos.shape[0]):
                     index=r+i
                     ele_pos[index]=tmp_ele_pos[i]
                 r=r+tmp_ele_pos.shape[0]
                 z+=1
             ######## GRAFIQUEMOS Y VEAMOS LOS DATOS DEL Pedestal
             fig, ax = plt.subplots(figsize=(16,8))
             print(time_azi_pos.shape)
             print(azi_pos.shape)
             t=numpy.arange(time_azi_pos.shape[0])*0.01/(60.0)
             plt.plot(t,azi_pos,label='AZIMUTH_POS',color='blue')
             # AQUI ESTOY ADICIONANDO LA POSICION EN elevaciont=numpy.arange(len(ele_pos))*0.01/60.0
             t=numpy.arange(len(ele_pos))*0.01/60.0
             plt.plot(t,ele_pos,label='ELEVATION_POS',color='red')#*10
             ax.set_xlim(0, 4)
             ax.set_ylim(-5, 360)
             plt.ylabel("Azimuth Position")
             plt.xlabel("Muestra")
             plt.title('Azimuth Position vs Muestra ', fontsize=20)
             axes = plt.gca()
             axes.yaxis.grid()
             plt.xticks(fontsize=16)
             plt.yticks(fontsize=16)
             plt.show()

schainpy/scripts/test_wradlib_RHI.py +14 0

             import numpy as np
             import matplotlib.pyplot as plt
             import wradlib as wrl
             import warnings
             # libreia nueva
             #export WRADLIB_DATA="/home/soporte/Downloads/2014-06-09--185000.rhi.mvol"
             from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
             warnings.filterwarnings('ignore')
             # lectura de gaMIC hdf5 file
             filename        = wrl.util.get_wradlib_data_file("/home/soporte/Downloads/2014-06-09--185000.rhi.mvol")
+            #filename        = wrl.util.get_wradlib_data_file("2014-06-09--185000.rhi.mvol")
             data1, metadata = wrl.io.read_gamic_hdf5(filename)
             print(data1)
             data1 = data1['SCAN0']['ZH']['data']
             print(data1)
             print("SHAPE Data",np.array(data1).shape)
             r = metadata['SCAN0']['r']
             print("r",r)
             print("longitud r",len(r))
             th = metadata['SCAN0']['el']
             print("th",th)
             print("longitud th",len(th))
             az = metadata['SCAN0']['az']
             print("az",az)
             site = (metadata['VOL']['Longitude'], metadata['VOL']['Latitude'],
                     metadata['VOL']['Height'])
             print("Longitud,Latitud,Altura",site)
             ma1 =  np.array(data1)
+            for i in range(3):
+                print("dark",ma1[i])
             '''
             mask_ind = np.where(data1 <= np.nanmin(data1))
             data1[mask_ind] = np.nan
             ma1 = np.ma.array(data1, mask=np.isnan(data1))
             '''
+            ####################### test ####################s
+            th=(np.arange(450)/10.0)+5
+            #th= np.roll(th,-2)
+            #th=np.where(a<7,np.nan,a)
+            ma1=np.roll(ma1,-2,axis=0)
+            for i in range(3):
+                print("green",ma1[i])
+            print("a",th)
+            #th = [i for i in reversed(a)]
+            ######################### test
             #cgax, pm = wrl.vis.plot_rhi(ma1,r=r,th=th,rf=1e3)
             fig = plt.figure(figsize=(10,8))
             cgax, pm = wrl.vis.plot_rhi(ma1,r=r,th=th,rf=1e3,fig=fig, ax=111,proj='cg')
             caax = cgax.parasites[0]
             paax = cgax.parasites[1]
             cgax.set_ylim(0, 14)
             #caax = cgax.parasites[0]
             #paax = cgax.parasites[1]
             #cgax, pm = wrl.vis.plot_rhi(ma1, r=r, th=th, rf=1e3, fig=fig, ax=111, proj='cg')
             txt = plt.title('Simple RHI',y=1.05)
             #cbar = plt.gcf().colorbar(pm, pad=0.05, ax=paax)
             cbar = plt.gcf().colorbar(pm, pad=0.05)
             cbar.set_label('reflectivity [dBZ]')
             caax.set_xlabel('x_range [km]')
             caax.set_ylabel('y_range [km]')
             plt.text(1.0, 1.05, 'azimuth', transform=caax.transAxes, va='bottom',ha='right')
             gh = cgax.get_grid_helper()
             # set theta to some nice values
             locs = [0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14.,
 ., 16., 17., 18., 20., 22., 25., 30., 35.,  40., 50., 60., 70., 80., 90.]
             gh.grid_finder.grid_locator1 = FixedLocator(locs)
             gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs]))
             plt.show()

schainpy/scripts/wr_marzo_v1_001.py +26 -10

             # 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 Y MODO ------------------------
             print("SETUP- RADAR METEOROLOGICO")
             IPP        = 400*1e-6
             V          = 6
             samp_rate  = 10# VERIFICAR
             MODE_TABLE = 1             #  PUEDE SER 1 O 0
             AXIS       = [1,1,1,1]     #  AZIMUTH 1 ELEVACION 0
             SPEED_AXIS = [10,10,10,10] #  VELOCIDAD
             ANGLE_AXIS = [20,25,30,15] #  ANGULOS
             mode_proc       = 0
             #-----------------------------PATH ADQ Y PEDESTAL-------------------------------
             #ath     = "/DATA_RM/TEST_MARTES_22_1M_1us"
             #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-171722"
             #path     = "/DATA_RM/DRONE01ABRIL"
             #path   = "/DATA_RM/DRONE01ABRIL1429"
             #path_ped = "/DATA_RM/TEST_PEDESTAL/P20220322-171722"
             #path = "/DATA_RM/DRONE01ABRIL1701"
             path = "/DATA_RM/DATA/Torre_con_bola_1649092242/rawdata"
+            path="/DATA_RM/DRONE01ABRIL1727"
-            path_ped = "/DATA_RM/DRONE01ABRIL1450"
+            #path_ped = "/DATA_RM/DRONE01ABRIL1450"
+            path_ped="/DATA_RM/TEST_PEDESTAL/P20220401-172744"
+            #path_ped = "/DATA_RM/DATA/Torre_con_bola_1649092242/position/2022-04-04T17-00-00"
             #-------------------------------------------------------------------------------
             figpath_pp     = "/home/soporte/Pictures/Torre_con_bola_1649092242"
             #figpath_pp     = "/home/soporte/Pictures/MARTES_22_PP_1M_1us"
             figpath_spec   = "/home/soporte/Pictures/MARTES_22_1M_1us"
             figpath_pp_ppi = "/home/soporte/Pictures/MARTES_22_1M_1us_PPI"
+            figpath_pp_rhi  = "/DATA_RM/LUNES04ABRIL_1200_RHI"
             #--------------------------OPCIONES---------------------------------------------
-            plot        = 1
             plot_ppi    = 0
-            integration = 0
+            plot        = 0
+            plot_rhi    = 1
+            integration = 1
             save        = 0
             plot_spec   = 0
             #---------------------------SAVE HDF5 PROCESADO/--------------------------------
             if save == 1:
                 if mode_proc==0:
                     path_save = '/DATA_RM/TEST_HDF5_PP_MAR22/6v'
                 else:
                     path_save = '/DATA_RM/TEST_HDF5_SPEC_MAR22/6v'
             print("[SETUP]-RADAR METEOROLOGICO-")
             print("* PATH data ADQ        :", path)
             print("* PATH data PED        :", path_ped)
             print("* SAMPLE RATE ADQ Mhz  :", samp_rate)
             print("* Velocidad Pedestal   :",V,"°/seg")
             print("* Configuracion del Pedestal *")
             print("*** AXIS      :",AXIS)
             print("*** SPEED_AXIS:",SPEED_AXIS)
             print("*** ANGLE_AXIS:",ANGLE_AXIS)
             num_alturas  = int(samp_rate*IPP*1e6)
             print("* Nro de Altura        :",num_alturas)
             ############################ NRO Perfiles PROCESAMIENTO ###################
             V=V
             n= int(1/(V*IPP))
             print("* n - NRO Perfiles Proc:", n )
             ################################## MODE ###################################
             print("* Modo de Operacion    :",mode_proc)
             if mode_proc ==0:
                 print("* Met. Seleccionado    : Pulse Pair")
             else:
                 print("* Met. Momentos        : Momentos")
             ################################## MODE ###################################
             print("* Grabado de datos     :",save)
             if save ==1:
                 if mode_proc==0:
                    print("[ ON ] MODE PULSEPAIR")
                 else:
                    print("[ ON ] MODE FREQUENCY")
             print("* Integracion de datos :",integration)
             print("* Ploteo de datos Parameters:", plot)
             if plot==1:
                 print("* Path PP plot    :", figpath_pp )
             if plot_ppi==1:
                 print("* Path PPI plot    :", figpath_pp_ppi )
             time.sleep(4)
             #remotefolder = "/home/wmaster/graficos"
             ################# RANGO DE PLOTEO######################################
             dBmin = '20'
             dBmax = '60'
             xmin  = '12.0' #17.1,17.5
             xmax  = '12.4' #17.2,17.8
             ymin  = '0'    #### PONER A 0
             ymax  = '1.0'    #### PONER A 8
             ########################FECHA##########################################
             str1 = datetime.date.today()
             today = str1.strftime("%Y/%m/%d")
             str2 = str1 - 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="2022/04/04",#today,
+                                                        startDate="2022/04/01",#today,
-                                                        endDate="2022/04/04",#today,
+                                                        endDate="2022/04/01",#today,
-                                                        startTime='12:11:05',#'17:39:25',
+                                                        startTime='00:10:05',#'17:39:25',
                                                         endTime='23:59:59',#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())
             '''
             opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
             opObj10.addParameter(name='id', value='10', format='int')
             opObj10.addParameter(name='zmin', value='0', format='int')
             opObj10.addParameter(name='zmax', value='3', format='int')
             opObj10.addParameter(name='type', value='iq')
             opObj10.addParameter(name='ymin', value='-1200', format='int')
             opObj10.addParameter(name='ymax', value='1200', format='int')
             #opObj10.addParameter(name='save', value=figpath, format='str')
             opObj10.addParameter(name='save_period', value=10, format='int')
             '''
             opObj11 = procUnitConfObjA.addOperation(name='setH0')
             opObj11.addParameter(name='h0', value='-1.2', format='float')
             opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
             opObj11.addParameter(name='minIndex', value='1', format='int')
             #opObj11.addParameter(name='maxIndex', value='1000', format='int')
             #opObj11.addParameter(name='maxIndex', value=str(int(num_alturas/4.0)), format='int')
              # CUARTA PARTE de 60 Km POR ESO ENTRE 4  - 15 Km
             opObj11.addParameter(name='maxIndex', value=str(int(num_alturas/20.0)), format='int')
              # CUARTA PARTE de 60 Km POR ESO ENTRE 10  - 6 Km
              # CUARTA PARTE de 60 Km POR ESO ENTRE 20  - 3 Km
+            '''
             procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
             procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int')
             procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int')
             #SpectraPlot
             opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
             opObj11.addParameter(name='id', value='1', format='int')
             opObj11.addParameter(name='wintitle', value='Spectra', format='str')
             #opObj11.addParameter(name='xmin', value=-0.01, format='float')
             #opObj11.addParameter(name='xmax', value=0.01, format='float')
             opObj11.addParameter(name='zmin', value=dBmin, format='int')
             opObj11.addParameter(name='zmax', value=dBmax, format='int')
             opObj11.addParameter(name='ymin', value=ymin, format='int')
             opObj11.addParameter(name='ymax', value=ymax, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             #opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
+            '''
             if mode_proc ==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='ymin', value=ymin)
                     opObj11.addParameter(name='ymax', value=ymax)
                     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.addParhirameter(name='dataList',value='dataPP_POWER,dataPP_DOP,utctime',format='list')#,format='list'
                 if integration==1:
                     opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation')
                     opObj11.addParameter(name='path_ped', value=path_ped)
                     opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
-                    opObj11.addParameter(name='wr_exp', value='PPI')
+                    #opObj11.addParameter(name='wr_exp', value='PPI')
+                    opObj11.addParameter(name='wr_exp', value='RHI')
                 if plot_ppi==1:
                     opObj11 = procUnitConfObjB.addOperation(name='Block360')
                     opObj11.addParameter(name='n', value='10', format='int')
                     opObj11.addParameter(name='mode', value=mode_proc, 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')
                     opObj11.addParameter(name='save', value=figpath_pp_ppi)
                     opObj11.addParameter(name='save_period', value=1)
+                if plot_rhi==1:
+                    opObj11 = procUnitConfObjB.addOperation(name='Block360')
+                    opObj11.addParameter(name='n', value='10', format='int')
+                    opObj11.addParameter(name='mode', value=mode_proc, 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='WeatherRHIPlot',optype='other')
+                    opObj11.addParameter(name='save', value=figpath_pp_rhi)
+                    opObj11.addParameter(name='save_period', value=1)
             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