schain Commit - r1483:c3f12c63a985 · Jicamarca Repository

Clean code and fix for one channel in WR

Juan C. Espinoza -

r1483:c3f12c63a985

parent child

Context file:

r1483:c3f12c63a985

Collapse all files

schainpy/model/graphics/jroplot_base.py +2 -2

                              if stitle is not None:
                                  figname = os.path.join(
                                      self.save,
-                                     self.save_code,
+                                     self.save_code + '_' + new_string,
                                      '{}_{}_{}.png'.format(
                                          self.save_code,
+                                         new_string,
                                          self.getDateTime(self.data.max_time).strftime(
                                              '%Y%m%d_%H%M%S',
                                              ),
-                                             new_string,
                                          )
                                      )
                              else:

schainpy/model/graphics/jroplot_parameters.py +5 -1432

This diff has been collapsed as it changes many lines, (1437 lines changed) Show them Hide them
			@@ -369,1433 +369,6 class PolarMapPlot(Plot):
	369	369	self.titles = ['{} {}'.format(
	370	370	self.data.parameters[x], title) for x in self.channels]
	371	371
	372		class WeatherPlot(Plot):
	373		CODE = 'weather'
	374		plot_name = 'weather'
	375		plot_type = 'ppistyle'
	376		buffering = False
	377
	378		def setup(self):
	379		self.ncols = 1
	380		self.nrows = 1
	381		self.width =8
	382		self.height =8
	383		self.nplots= 1
	384		self.ylabel= 'Range [Km]'
	385		self.titles= ['Weather']
	386		self.colorbar=False
	387		self.ini =0
	388		self.len_azi =0
	389		self.buffer_ini = None
	390		self.buffer_azi = None
	391		self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	392		self.flag =0
	393		self.indicador= 0
	394		self.last_data_azi = None
	395		self.val_mean = None
	396
	397		def update(self, dataOut):
	398
	399		data = {}
	400		meta = {}
	401		if hasattr(dataOut, 'dataPP_POWER'):
	402		factor = 1
	403		if hasattr(dataOut, 'nFFTPoints'):
	404		factor = dataOut.normFactor
	405		#print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
	406		data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	407		data['azi'] = dataOut.data_azi
	408		data['ele'] = dataOut.data_ele
	409		return data, meta
	410
	411		def get2List(self,angulos):
	412		list1=[]
	413		list2=[]
	414		for i in reversed(range(len(angulos))):
	415		diff_ = angulos[i]-angulos[i-1]
	416		if diff_ >1.5:
	417		list1.append(i-1)
	418		list2.append(diff_)
	419		return list(reversed(list1)),list(reversed(list2))
	420
	421		def fixData360(self,list_,ang_):
	422		if list_[0]==-1:
	423		vec = numpy.where(ang_<ang_[0])
	424		ang_[vec] = ang_[vec]+360
	425		return ang_
	426		return ang_
	427
	428		def fixData360HL(self,angulos):
	429		vec = numpy.where(angulos>=360)
	430		angulos[vec]=angulos[vec]-360
	431		return angulos
	432
	433		def search_pos(self,pos,list_):
	434		for i in range(len(list_)):
	435		if pos == list_[i]:
	436		return True,i
	437		i=None
	438		return False,i
	439
	440		def fixDataComp(self,ang_,list1_,list2_):
	441		size = len(ang_)
	442		size2 = 0
	443		for i in range(len(list2_)):
	444		size2=size2+round(list2_[i])-1
	445		new_size= size+size2
	446		ang_new = numpy.zeros(new_size)
	447		ang_new2 = numpy.zeros(new_size)
	448
	449		tmp = 0
	450		c = 0
	451		for i in range(len(ang_)):
	452		ang_new[tmp +c] = ang_[i]
	453		ang_new2[tmp+c] = ang_[i]
	454		condition , value = self.search_pos(i,list1_)
	455		if condition:
	456		pos = tmp + c + 1
	457		for k in range(round(list2_[value])-1):
	458		ang_new[pos+k] = ang_new[pos+k-1]+1
	459		ang_new2[pos+k] = numpy.nan
	460		tmp = pos +k
	461		c = 0
	462		c=c+1
	463		return ang_new,ang_new2
	464
	465		def globalCheckPED(self,angulos):
	466		l1,l2 = self.get2List(angulos)
	467		if len(l1)>0:
	468		angulos2 = self.fixData360(list_=l1,ang_=angulos)
	469		l1,l2 = self.get2List(angulos2)
	470
	471		ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
	472		ang1_ = self.fixData360HL(ang1_)
	473		ang2_ = self.fixData360HL(ang2_)
	474		else:
	475		ang1_= angulos
	476		ang2_= angulos
	477		return ang1_,ang2_
	478
	479		def analizeDATA(self,data_azi):
	480		list1 = []
	481		list2 = []
	482		dat = data_azi
	483		for i in reversed(range(1,len(dat))):
	484		if dat[i]>dat[i-1]:
	485		diff = int(dat[i])-int(dat[i-1])
	486		else:
	487		diff = 360+int(dat[i])-int(dat[i-1])
	488		if diff > 1:
	489		list1.append(i-1)
	490		list2.append(diff-1)
	491		return list1,list2
	492
	493		def fixDATANEW(self,data_azi,data_weather):
	494		list1,list2 = self.analizeDATA(data_azi)
	495		if len(list1)== 0:
	496		return data_azi,data_weather
	497		else:
	498		resize = 0
	499		for i in range(len(list2)):
	500		resize= resize + list2[i]
	501		new_data_azi = numpy.resize(data_azi,resize)
	502		new_data_weather= numpy.resize(date_weather,resize)
	503
	504		for i in range(len(list2)):
	505		j=0
	506		position=list1[i]+1
	507		for j in range(list2[i]):
	508		new_data_azi[position+j]=new_data_azi[position+j-1]+1
	509		return new_data_azi
	510
	511		def fixDATA(self,data_azi):
	512		data=data_azi
	513		for i in range(len(data)):
	514		if numpy.isnan(data[i]):
	515		data[i]=data[i-1]+1
	516		return data
	517
	518		def replaceNAN(self,data_weather,data_azi,val):
	519		data= data_azi
	520		data_T= data_weather
	521		if data.shape[0]> data_T.shape[0]:
	522		data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	523		c = 0
	524		for i in range(len(data)):
	525		if numpy.isnan(data[i]):
	526		data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	527		else:
	528		data_N[i,:]=data_T[c,:]
	529		c=c+1
	530		return data_N
	531		else:
	532		for i in range(len(data)):
	533		if numpy.isnan(data[i]):
	534		data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	535		return data_T
	536
	537		def const_ploteo(self,data_weather,data_azi,step,res):
	538		if self.ini==0:
	539		#-------
	540		n = (360/res)-len(data_azi)
	541		#--------------------- new -------------------------
	542		data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
	543		#------------------------
	544		start = data_azi_new[-1] + res
	545		end = data_azi_new[0] - res
	546		#------ new
	547		self.last_data_azi = end
	548		if start>end:
	549		end = end + 360
	550		azi_vacia = numpy.linspace(start,end,int(n))
	551		azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
	552		data_azi = numpy.hstack((data_azi_new,azi_vacia))
	553		# RADAR
	554		val_mean = numpy.mean(data_weather[:,-1])
	555		self.val_mean = val_mean
	556		data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
	557		data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
	558		data_weather = numpy.vstack((data_weather,data_weather_cmp))
	559		else:
	560		# azimuth
	561		flag=0
	562		start_azi = self.res_azi[0]
	563		#-----------new------------
	564		data_azi ,data_azi_old= self.globalCheckPED(data_azi)
	565		data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
	566		#--------------------------
	567		start = data_azi[0]
	568		end = data_azi[-1]
	569		self.last_data_azi= end
	570		if start< start_azi:
	571		start = start +360
	572		if end <start_azi:
	573		end = end +360
	574
	575		pos_ini = int((start-start_azi)/res)
	576		len_azi = len(data_azi)
	577		if (360-pos_ini)<len_azi:
	578		if pos_ini+1==360:
	579		pos_ini=0
	580		else:
	581		flag=1
	582		dif= 360-pos_ini
	583		comp= len_azi-dif
	584		#-----------------
	585		if flag==0:
	586		# AZIMUTH
	587		self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
	588		# RADAR
	589		self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
	590		else:
	591		# AZIMUTH
	592		self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
	593		self.res_azi[0:comp] = data_azi[dif:]
	594		# RADAR
	595		self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
	596		self.res_weather[0:comp,:] = data_weather[dif:,:]
	597		flag=0
	598		data_azi = self.res_azi
	599		data_weather = self.res_weather
	600
	601		return data_weather,data_azi
	602
	603		def plot(self):
	604		thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	605		data = self.data[-1]
	606		r = self.data.yrange
	607		delta_height = r[1]-r[0]
	608		r_mask = numpy.where(r>=0)[0]
	609		r = numpy.arange(len(r_mask))*delta_height
	610		self.y = 2*r
	611		# RADAR
	612		#data_weather = data['weather']
	613		# PEDESTAL
	614		#data_azi = data['azi']
	615		res = 1
	616		# STEP
	617		step = (360/(res*data['weather'].shape[0]))
	618
	619		self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
	620		self.res_ele = numpy.mean(data['ele'])
	621		################# PLOTEO ###################
	622		for i,ax in enumerate(self.axes):
	623		self.zmin = self.zmin if self.zmin else 20
	624		self.zmax = self.zmax if self.zmax else 80
	625		if ax.firsttime:
	626		plt.clf()
	627		cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
	628		else:
	629		plt.clf()
	630		cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
	631		caax = cgax.parasites[0]
	632		paax = cgax.parasites[1]
	633		cbar = plt.gcf().colorbar(pm, pad=0.075)
	634		caax.set_xlabel('x_range [km]')
	635		caax.set_ylabel('y_range [km]')
	636		plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " EL: "+str(round(self.res_ele, 1)), transform=caax.transAxes, va='bottom',ha='right')
	637
	638		self.ini= self.ini+1
	639
	640
	641		class WeatherRHIPlot(Plot):
	642		CODE = 'weather'
	643		plot_name = 'weather'
	644		plot_type = 'rhistyle'
	645		buffering = False
	646		data_ele_tmp = None
	647
	648		def setup(self):
	649		print("********************")
	650		print("********************")
	651		print("********************")
	652		print("SETUP WEATHER PLOT")
	653		self.ncols = 1
	654		self.nrows = 1
	655		self.nplots= 1
	656		self.ylabel= 'Range [Km]'
	657		self.titles= ['Weather']
	658		if self.channels is not None:
	659		self.nplots = len(self.channels)
	660		self.nrows = len(self.channels)
	661		else:
	662		self.nplots = self.data.shape(self.CODE)[0]
	663		self.nrows = self.nplots
	664		self.channels = list(range(self.nplots))
	665		print("channels",self.channels)
	666		print("que saldra", self.data.shape(self.CODE)[0])
	667		self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	668		print("self.titles",self.titles)
	669		self.colorbar=False
	670		self.width =12
	671		self.height =8
	672		self.ini =0
	673		self.len_azi =0
	674		self.buffer_ini = None
	675		self.buffer_ele = None
	676		self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	677		self.flag =0
	678		self.indicador= 0
	679		self.last_data_ele = None
	680		self.val_mean = None
	681
	682		def update(self, dataOut):
	683
	684		data = {}
	685		meta = {}
	686		if hasattr(dataOut, 'dataPP_POWER'):
	687		factor = 1
	688		if hasattr(dataOut, 'nFFTPoints'):
	689		factor = dataOut.normFactor
	690		print("dataOut",dataOut.data_360.shape)
	691		#
	692		data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
	693		#
	694		#data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	695		data['azi'] = dataOut.data_azi
	696		data['ele'] = dataOut.data_ele
	697		#print("UPDATE")
	698		#print("data[weather]",data['weather'].shape)
	699		#print("data[azi]",data['azi'])
	700		return data, meta
	701
	702		def get2List(self,angulos):
	703		list1=[]
	704		list2=[]
	705		for i in reversed(range(len(angulos))):
	706		if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
	707		diff_ = angulos[i]-angulos[i-1]
	708		if abs(diff_) >1.5:
	709		list1.append(i-1)
	710		list2.append(diff_)
	711		return list(reversed(list1)),list(reversed(list2))
	712
	713		def fixData90(self,list_,ang_):
	714		if list_[0]==-1:
	715		vec = numpy.where(ang_<ang_[0])
	716		ang_[vec] = ang_[vec]+90
	717		return ang_
	718		return ang_
	719
	720		def fixData90HL(self,angulos):
	721		vec = numpy.where(angulos>=90)
	722		angulos[vec]=angulos[vec]-90
	723		return angulos
	724
	725
	726		def search_pos(self,pos,list_):
	727		for i in range(len(list_)):
	728		if pos == list_[i]:
	729		return True,i
	730		i=None
	731		return False,i
	732
	733		def fixDataComp(self,ang_,list1_,list2_,tipo_case):
	734		size = len(ang_)
	735		size2 = 0
	736		for i in range(len(list2_)):
	737		size2=size2+round(abs(list2_[i]))-1
	738		new_size= size+size2
	739		ang_new = numpy.zeros(new_size)
	740		ang_new2 = numpy.zeros(new_size)
	741
	742		tmp = 0
	743		c = 0
	744		for i in range(len(ang_)):
	745		ang_new[tmp +c] = ang_[i]
	746		ang_new2[tmp+c] = ang_[i]
	747		condition , value = self.search_pos(i,list1_)
	748		if condition:
	749		pos = tmp + c + 1
	750		for k in range(round(abs(list2_[value]))-1):
	751		if tipo_case==0 or tipo_case==3:#subida
	752		ang_new[pos+k] = ang_new[pos+k-1]+1
	753		ang_new2[pos+k] = numpy.nan
	754		elif tipo_case==1 or tipo_case==2:#bajada
	755		ang_new[pos+k] = ang_new[pos+k-1]-1
	756		ang_new2[pos+k] = numpy.nan
	757
	758		tmp = pos +k
	759		c = 0
	760		c=c+1
	761		return ang_new,ang_new2
	762
	763		def globalCheckPED(self,angulos,tipo_case):
	764		l1,l2 = self.get2List(angulos)
	765		##print("l1",l1)
	766		##print("l2",l2)
	767		if len(l1)>0:
	768		#angulos2 = self.fixData90(list_=l1,ang_=angulos)
	769		#l1,l2 = self.get2List(angulos2)
	770		ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
	771		#ang1_ = self.fixData90HL(ang1_)
	772		#ang2_ = self.fixData90HL(ang2_)
	773		else:
	774		ang1_= angulos
	775		ang2_= angulos
	776		return ang1_,ang2_
	777
	778
	779		def replaceNAN(self,data_weather,data_ele,val):
	780		data= data_ele
	781		data_T= data_weather
	782		if data.shape[0]> data_T.shape[0]:
	783		data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	784		c = 0
	785		for i in range(len(data)):
	786		if numpy.isnan(data[i]):
	787		data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	788		else:
	789		data_N[i,:]=data_T[c,:]
	790		c=c+1
	791		return data_N
	792		else:
	793		for i in range(len(data)):
	794		if numpy.isnan(data[i]):
	795		data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	796		return data_T
	797
	798		def check_case(self,data_ele,ang_max,ang_min):
	799		start = data_ele[0]
	800		end = data_ele[-1]
	801		number = (end-start)
	802		len_ang=len(data_ele)
	803		print("start",start)
	804		print("end",end)
	805		print("number",number)
	806
	807		print("len_ang",len_ang)
	808
	809		#exit(1)
	810
	811		if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
	812		return 0
	813		#elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
	814		# return 1
	815		elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
	816		return 1
	817		elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
	818		return 2
	819		elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
	820		return 3
	821
	822
	823		def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
	824		ang_max= ang_max
	825		ang_min= ang_min
	826		data_weather=data_weather
	827		val_ch=val_ch
	828		##print("*******************DATA WEATHER************************************")
	829		##print(data_weather)
	830		if self.ini==0:
	831		'''
	832		print("**********************************************")
	833		print("**********************************************")
	834		print("*************ini************")
	835		print("**********************************************")
	836		print("**********************************************")
	837		'''
	838		#print("data_ele",data_ele)
	839		#----------------------------------------------------------
	840		tipo_case = self.check_case(data_ele,ang_max,ang_min)
	841		print("check_case",tipo_case)
	842		#exit(1)
	843		#--------------------- new -------------------------
	844		data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
	845
	846		#-------------------------CAMBIOS RHI---------------------------------
	847		start= ang_min
	848		end = ang_max
	849		n= (ang_max-ang_min)/res
	850		#------ new
	851		self.start_data_ele = data_ele_new[0]
	852		self.end_data_ele = data_ele_new[-1]
	853		if tipo_case==0 or tipo_case==3: # SUBIDA
	854		n1= round(self.start_data_ele)- start
	855		n2= end - round(self.end_data_ele)
	856		print(self.start_data_ele)
	857		print(self.end_data_ele)
	858		if n1>0:
	859		ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	860		ele1_nan= numpy.ones(n1)*numpy.nan
	861		data_ele = numpy.hstack((ele1,data_ele_new))
	862		print("ele1_nan",ele1_nan.shape)
	863		print("data_ele_old",data_ele_old.shape)
	864		data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	865		if n2>0:
	866		ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	867		ele2_nan= numpy.ones(n2)*numpy.nan
	868		data_ele = numpy.hstack((data_ele,ele2))
	869		print("ele2_nan",ele2_nan.shape)
	870		print("data_ele_old",data_ele_old.shape)
	871		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	872
	873		if tipo_case==1 or tipo_case==2: # BAJADA
	874		data_ele_new = data_ele_new[::-1] # reversa
	875		data_ele_old = data_ele_old[::-1]# reversa
	876		data_weather = data_weather[::-1,:]# reversa
	877		vec= numpy.where(data_ele_new<ang_max)
	878		data_ele_new = data_ele_new[vec]
	879		data_ele_old = data_ele_old[vec]
	880		data_weather = data_weather[vec[0]]
	881		vec2= numpy.where(0<data_ele_new)
	882		data_ele_new = data_ele_new[vec2]
	883		data_ele_old = data_ele_old[vec2]
	884		data_weather = data_weather[vec2[0]]
	885		self.start_data_ele = data_ele_new[0]
	886		self.end_data_ele = data_ele_new[-1]
	887
	888		n1= round(self.start_data_ele)- start
	889		n2= end - round(self.end_data_ele)-1
	890		print(self.start_data_ele)
	891		print(self.end_data_ele)
	892		if n1>0:
	893		ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	894		ele1_nan= numpy.ones(n1)*numpy.nan
	895		data_ele = numpy.hstack((ele1,data_ele_new))
	896		data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	897		if n2>0:
	898		ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	899		ele2_nan= numpy.ones(n2)*numpy.nan
	900		data_ele = numpy.hstack((data_ele,ele2))
	901		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	902		# RADAR
	903		# NOTA data_ele y data_weather es la variable que retorna
	904		val_mean = numpy.mean(data_weather[:,-1])
	905		self.val_mean = val_mean
	906		data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	907		self.data_ele_tmp[val_ch]= data_ele_old
	908		else:
	909		#print("**********************************************")
	910		#print("**************VARIABLE********************")
	911		#-------------------------CAMBIOS RHI---------------------------------
	912		#---------------------------------------------------------------------
	913		##print("INPUT data_ele",data_ele)
	914		flag=0
	915		start_ele = self.res_ele[0]
	916		tipo_case = self.check_case(data_ele,ang_max,ang_min)
	917		#print("TIPO DE DATA",tipo_case)
	918		#-----------new------------
	919		data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
	920		data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	921
	922		#-------------------------------NEW RHI ITERATIVO-------------------------
	923
	924		if tipo_case==0 : # SUBIDA
	925		vec = numpy.where(data_ele<ang_max)
	926		data_ele = data_ele[vec]
	927		data_ele_old = data_ele_old[vec]
	928		data_weather = data_weather[vec[0]]
	929
	930		vec2 = numpy.where(0<data_ele)
	931		data_ele= data_ele[vec2]
	932		data_ele_old= data_ele_old[vec2]
	933		##print(data_ele_new)
	934		data_weather= data_weather[vec2[0]]
	935
	936		new_i_ele = int(round(data_ele[0]))
	937		new_f_ele = int(round(data_ele[-1]))
	938		#print(new_i_ele)
	939		#print(new_f_ele)
	940		#print(data_ele,len(data_ele))
	941		#print(data_ele_old,len(data_ele_old))
	942		if new_i_ele< 2:
	943		self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	944		self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	945		self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
	946		self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
	947		self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
	948		data_ele = self.res_ele
	949		data_weather = self.res_weather[val_ch]
	950
	951		elif tipo_case==1 : #BAJADA
	952		data_ele = data_ele[::-1] # reversa
	953		data_ele_old = data_ele_old[::-1]# reversa
	954		data_weather = data_weather[::-1,:]# reversa
	955		vec= numpy.where(data_ele<ang_max)
	956		data_ele = data_ele[vec]
	957		data_ele_old = data_ele_old[vec]
	958		data_weather = data_weather[vec[0]]
	959		vec2= numpy.where(0<data_ele)
	960		data_ele = data_ele[vec2]
	961		data_ele_old = data_ele_old[vec2]
	962		data_weather = data_weather[vec2[0]]
	963
	964
	965		new_i_ele = int(round(data_ele[0]))
	966		new_f_ele = int(round(data_ele[-1]))
	967		#print(data_ele)
	968		#print(ang_max)
	969		#print(data_ele_old)
	970		if new_i_ele <= 1:
	971		new_i_ele = 1
	972		if round(data_ele[-1])>=ang_max-1:
	973		self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	974		self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	975		self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
	976		self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
	977		self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
	978		data_ele = self.res_ele
	979		data_weather = self.res_weather[val_ch]
	980
	981		elif tipo_case==2: #bajada
	982		vec = numpy.where(data_ele<ang_max)
	983		data_ele = data_ele[vec]
	984		data_weather= data_weather[vec[0]]
	985
	986		len_vec = len(vec)
	987		data_ele_new = data_ele[::-1] # reversa
	988		data_weather = data_weather[::-1,:]
	989		new_i_ele = int(data_ele_new[0])
	990		new_f_ele = int(data_ele_new[-1])
	991
	992		n1= new_i_ele- ang_min
	993		n2= ang_max - new_f_ele-1
	994		if n1>0:
	995		ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	996		ele1_nan= numpy.ones(n1)*numpy.nan
	997		data_ele = numpy.hstack((ele1,data_ele_new))
	998		data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	999		if n2>0:
	1000		ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1001		ele2_nan= numpy.ones(n2)*numpy.nan
	1002		data_ele = numpy.hstack((data_ele,ele2))
	1003		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1004
	1005		self.data_ele_tmp[val_ch] = data_ele_old
	1006		self.res_ele = data_ele
	1007		self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1008		data_ele = self.res_ele
	1009		data_weather = self.res_weather[val_ch]
	1010
	1011		elif tipo_case==3:#subida
	1012		vec = numpy.where(0<data_ele)
	1013		data_ele= data_ele[vec]
	1014		data_ele_new = data_ele
	1015		data_ele_old= data_ele_old[vec]
	1016		data_weather= data_weather[vec[0]]
	1017		pos_ini = numpy.argmin(data_ele)
	1018		if pos_ini>0:
	1019		len_vec= len(data_ele)
	1020		vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
	1021		#print(vec3)
	1022		data_ele= data_ele[vec3]
	1023		data_ele_new = data_ele
	1024		data_ele_old= data_ele_old[vec3]
	1025		data_weather= data_weather[vec3]
	1026
	1027		new_i_ele = int(data_ele_new[0])
	1028		new_f_ele = int(data_ele_new[-1])
	1029		n1= new_i_ele- ang_min
	1030		n2= ang_max - new_f_ele-1
	1031		if n1>0:
	1032		ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1033		ele1_nan= numpy.ones(n1)*numpy.nan
	1034		data_ele = numpy.hstack((ele1,data_ele_new))
	1035		data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1036		if n2>0:
	1037		ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1038		ele2_nan= numpy.ones(n2)*numpy.nan
	1039		data_ele = numpy.hstack((data_ele,ele2))
	1040		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1041
	1042		self.data_ele_tmp[val_ch] = data_ele_old
	1043		self.res_ele = data_ele
	1044		self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1045		data_ele = self.res_ele
	1046		data_weather = self.res_weather[val_ch]
	1047		#print("self.data_ele_tmp",self.data_ele_tmp)
	1048		return data_weather,data_ele
	1049
	1050
	1051		def plot(self):
	1052		thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	1053		data = self.data[-1]
	1054		r = self.data.yrange
	1055		delta_height = r[1]-r[0]
	1056		r_mask = numpy.where(r>=0)[0]
	1057		##print("delta_height",delta_height)
	1058		#print("r_mask",r_mask,len(r_mask))
	1059		r = numpy.arange(len(r_mask))*delta_height
	1060		self.y = 2*r
	1061		res = 1
	1062		###print("data['weather'].shape[0]",data['weather'].shape[0])
	1063		ang_max = self.ang_max
	1064		ang_min = self.ang_min
	1065		var_ang =ang_max - ang_min
	1066		step = (int(var_ang)/(res*data['weather'].shape[0]))
	1067		###print("step",step)
	1068		#--------------------------------------------------------
	1069		##print('weather',data['weather'].shape)
	1070		##print('ele',data['ele'].shape)
	1071
	1072		###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)
	1073		###self.res_azi = numpy.mean(data['azi'])
	1074		###print("self.res_ele",self.res_ele)
	1075		plt.clf()
	1076		subplots = [121, 122]
	1077		cg={'angular_spacing': 20.}
	1078		if self.ini==0:
	1079		self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
	1080		self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
	1081		print("SHAPE",self.data_ele_tmp.shape)
	1082
	1083		for i,ax in enumerate(self.axes):
	1084		self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
	1085		self.res_azi = numpy.mean(data['azi'])
	1086		if i==0:
	1087		print("***************************************************************************to plot************************",self.res_weather[i].shape)
	1088		self.zmin = self.zmin if self.zmin else 20
	1089		self.zmax = self.zmax if self.zmax else 80
	1090		if ax.firsttime:
	1091		#plt.clf()
	1092		cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
	1093		#fig=self.figures[0]
	1094		else:
	1095		#plt.clf()
	1096		if i==0:
	1097		print(self.res_weather[i])
	1098		print(self.res_ele)
	1099		cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
	1100		caax = cgax.parasites[0]
	1101		paax = cgax.parasites[1]
	1102		cbar = plt.gcf().colorbar(pm, pad=0.075)
	1103		caax.set_xlabel('x_range [km]')
	1104		caax.set_ylabel('y_range [km]')
	1105		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')
	1106		print("*************************self.ini**************************",self.ini)
	1107		self.ini= self.ini+1
	1108
	1109		class Weather_vRF_Plot(Plot):
	1110		CODE = 'PPI'
	1111		plot_name = 'PPI'
	1112		#plot_type = 'ppistyle'
	1113		buffering = False
	1114
	1115		def setup(self):
	1116
	1117		self.ncols = 1
	1118		self.nrows = 1
	1119		self.width =8
	1120		self.height =8
	1121		self.nplots= 1
	1122		self.ylabel= 'Range [Km]'
	1123		self.xlabel= 'Range [Km]'
	1124		self.titles= ['PPI']
	1125		self.polar = True
	1126		if self.channels is not None:
	1127		self.nplots = len(self.channels)
	1128		self.nrows = len(self.channels)
	1129		else:
	1130		self.nplots = self.data.shape(self.CODE)[0]
	1131		self.nrows = self.nplots
	1132		self.channels = list(range(self.nplots))
	1133
	1134		if self.CODE == 'POWER':
	1135		self.cb_label = r'Power (dB)'
	1136		elif self.CODE == 'DOPPLER':
	1137		self.cb_label = r'Velocity (m/s)'
	1138		self.colorbar=True
	1139		self.width = 9
	1140		self.height =8
	1141		self.ini =0
	1142		self.len_azi =0
	1143		self.buffer_ini = None
	1144		self.buffer_ele = None
	1145		self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.15, 'right': 0.9, 'bottom': 0.08})
	1146		self.flag =0
	1147		self.indicador= 0
	1148		self.last_data_ele = None
	1149		self.val_mean = None
	1150
	1151		def update(self, dataOut):
	1152
	1153		data = {}
	1154		meta = {}
	1155		if hasattr(dataOut, 'dataPP_POWER'):
	1156		factor = 1
	1157		if hasattr(dataOut, 'nFFTPoints'):
	1158		factor = dataOut.normFactor
	1159
	1160		if 'pow' in self.attr_data[0].lower():
	1161		data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
	1162		else:
	1163		data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
	1164
	1165		data['azi'] = dataOut.data_azi
	1166		data['ele'] = dataOut.data_ele
	1167
	1168		return data, meta
	1169
	1170		def plot(self):
	1171		data = self.data[-1]
	1172		r = self.data.yrange
	1173		delta_height = r[1]-r[0]
	1174		r_mask = numpy.where(r>=0)[0]
	1175		self.r_mask = r_mask
	1176		r = numpy.arange(len(r_mask))*delta_height
	1177		self.y = 2*r
	1178
	1179		try:
	1180		z = data['data'][self.channels[0]][:,r_mask]
	1181
	1182		except:
	1183		z = data['data'][0][:,r_mask]
	1184
	1185		self.titles = []
	1186
	1187		self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
	1188		self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1189		self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1190		self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1191		self.ang_min = self.ang_min if self.ang_min else 0
	1192		self.ang_max = self.ang_max if self.ang_max else 360
	1193
	1194		r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
	1195
	1196		for i,ax in enumerate(self.axes):
	1197
	1198		if ax.firsttime:
	1199		ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1200		ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1201		ax.set_theta_direction(-1)
	1202
	1203		else:
	1204		ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1205		ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1206		ax.set_theta_direction(-1)
	1207
	1208		ax.grid(True)
	1209
	1210		if len(self.channels) !=1:
	1211		self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(numpy.mean(data['ele']),1)), x) for x in range(self.nrows)]
	1212		else:
	1213		self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])]
	1214
	1215		class WeatherRHI_vRF2_Plot(Plot):
	1216		CODE = 'weather'
	1217		plot_name = 'weather'
	1218		plot_type = 'rhistyle'
	1219		buffering = False
	1220		data_ele_tmp = None
	1221
	1222		def setup(self):
	1223		print("********************")
	1224		print("********************")
	1225		print("********************")
	1226		print("SETUP WEATHER PLOT")
	1227		self.ncols = 1
	1228		self.nrows = 1
	1229		self.nplots= 1
	1230		self.ylabel= 'Range [Km]'
	1231		self.titles= ['Weather']
	1232		if self.channels is not None:
	1233		self.nplots = len(self.channels)
	1234		self.nrows = len(self.channels)
	1235		else:
	1236		self.nplots = self.data.shape(self.CODE)[0]
	1237		self.nrows = self.nplots
	1238		self.channels = list(range(self.nplots))
	1239		print("channels",self.channels)
	1240		print("que saldra", self.data.shape(self.CODE)[0])
	1241		self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	1242		print("self.titles",self.titles)
	1243		self.colorbar=False
	1244		self.width =8
	1245		self.height =8
	1246		self.ini =0
	1247		self.len_azi =0
	1248		self.buffer_ini = None
	1249		self.buffer_ele = None
	1250		self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	1251		self.flag =0
	1252		self.indicador= 0
	1253		self.last_data_ele = None
	1254		self.val_mean = None
	1255
	1256		def update(self, dataOut):
	1257
	1258		data = {}
	1259		meta = {}
	1260		if hasattr(dataOut, 'dataPP_POWER'):
	1261		factor = 1
	1262		if hasattr(dataOut, 'nFFTPoints'):
	1263		factor = dataOut.normFactor
	1264		print("dataOut",dataOut.data_360.shape)
	1265		#
	1266		data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
	1267		#
	1268		#data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
	1269		data['azi'] = dataOut.data_azi
	1270		data['ele'] = dataOut.data_ele
	1271		data['case_flag'] = dataOut.case_flag
	1272		#print("UPDATE")
	1273		#print("data[weather]",data['weather'].shape)
	1274		#print("data[azi]",data['azi'])
	1275		return data, meta
	1276
	1277		def get2List(self,angulos):
	1278		list1=[]
	1279		list2=[]
	1280		for i in reversed(range(len(angulos))):
	1281		if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
	1282		diff_ = angulos[i]-angulos[i-1]
	1283		if abs(diff_) >1.5:
	1284		list1.append(i-1)
	1285		list2.append(diff_)
	1286		return list(reversed(list1)),list(reversed(list2))
	1287
	1288		def fixData90(self,list_,ang_):
	1289		if list_[0]==-1:
	1290		vec = numpy.where(ang_<ang_[0])
	1291		ang_[vec] = ang_[vec]+90
	1292		return ang_
	1293		return ang_
	1294
	1295		def fixData90HL(self,angulos):
	1296		vec = numpy.where(angulos>=90)
	1297		angulos[vec]=angulos[vec]-90
	1298		return angulos
	1299
	1300
	1301		def search_pos(self,pos,list_):
	1302		for i in range(len(list_)):
	1303		if pos == list_[i]:
	1304		return True,i
	1305		i=None
	1306		return False,i
	1307
	1308		def fixDataComp(self,ang_,list1_,list2_,tipo_case):
	1309		size = len(ang_)
	1310		size2 = 0
	1311		for i in range(len(list2_)):
	1312		size2=size2+round(abs(list2_[i]))-1
	1313		new_size= size+size2
	1314		ang_new = numpy.zeros(new_size)
	1315		ang_new2 = numpy.zeros(new_size)
	1316
	1317		tmp = 0
	1318		c = 0
	1319		for i in range(len(ang_)):
	1320		ang_new[tmp +c] = ang_[i]
	1321		ang_new2[tmp+c] = ang_[i]
	1322		condition , value = self.search_pos(i,list1_)
	1323		if condition:
	1324		pos = tmp + c + 1
	1325		for k in range(round(abs(list2_[value]))-1):
	1326		if tipo_case==0 or tipo_case==3:#subida
	1327		ang_new[pos+k] = ang_new[pos+k-1]+1
	1328		ang_new2[pos+k] = numpy.nan
	1329		elif tipo_case==1 or tipo_case==2:#bajada
	1330		ang_new[pos+k] = ang_new[pos+k-1]-1
	1331		ang_new2[pos+k] = numpy.nan
	1332
	1333		tmp = pos +k
	1334		c = 0
	1335		c=c+1
	1336		return ang_new,ang_new2
	1337
	1338		def globalCheckPED(self,angulos,tipo_case):
	1339		l1,l2 = self.get2List(angulos)
	1340		##print("l1",l1)
	1341		##print("l2",l2)
	1342		if len(l1)>0:
	1343		#angulos2 = self.fixData90(list_=l1,ang_=angulos)
	1344		#l1,l2 = self.get2List(angulos2)
	1345		ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
	1346		#ang1_ = self.fixData90HL(ang1_)
	1347		#ang2_ = self.fixData90HL(ang2_)
	1348		else:
	1349		ang1_= angulos
	1350		ang2_= angulos
	1351		return ang1_,ang2_
	1352
	1353
	1354		def replaceNAN(self,data_weather,data_ele,val):
	1355		data= data_ele
	1356		data_T= data_weather
	1357		if data.shape[0]> data_T.shape[0]:
	1358		data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
	1359		c = 0
	1360		for i in range(len(data)):
	1361		if numpy.isnan(data[i]):
	1362		data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	1363		else:
	1364		data_N[i,:]=data_T[c,:]
	1365		c=c+1
	1366		return data_N
	1367		else:
	1368		for i in range(len(data)):
	1369		if numpy.isnan(data[i]):
	1370		data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
	1371		return data_T
	1372
	1373		def check_case(self,data_ele,ang_max,ang_min):
	1374		start = data_ele[0]
	1375		end = data_ele[-1]
	1376		number = (end-start)
	1377		len_ang=len(data_ele)
	1378		print("start",start)
	1379		print("end",end)
	1380		print("number",number)
	1381
	1382		print("len_ang",len_ang)
	1383
	1384		#exit(1)
	1385
	1386		if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
	1387		return 0
	1388		#elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
	1389		# return 1
	1390		elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
	1391		return 1
	1392		elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
	1393		return 2
	1394		elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
	1395		return 3
	1396
	1397
	1398		def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
	1399		ang_max= ang_max
	1400		ang_min= ang_min
	1401		data_weather=data_weather
	1402		val_ch=val_ch
	1403		##print("*******************DATA WEATHER************************************")
	1404		##print(data_weather)
	1405		if self.ini==0:
	1406		'''
	1407		print("**********************************************")
	1408		print("**********************************************")
	1409		print("*************ini************")
	1410		print("**********************************************")
	1411		print("**********************************************")
	1412		'''
	1413		#print("data_ele",data_ele)
	1414		#----------------------------------------------------------
	1415		tipo_case = case_flag[-1]
	1416		#tipo_case = self.check_case(data_ele,ang_max,ang_min)
	1417		print("check_case",tipo_case)
	1418		#exit(1)
	1419		#--------------------- new -------------------------
	1420		data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
	1421
	1422		#-------------------------CAMBIOS RHI---------------------------------
	1423		start= ang_min
	1424		end = ang_max
	1425		n= (ang_max-ang_min)/res
	1426		#------ new
	1427		self.start_data_ele = data_ele_new[0]
	1428		self.end_data_ele = data_ele_new[-1]
	1429		if tipo_case==0 or tipo_case==3: # SUBIDA
	1430		n1= round(self.start_data_ele)- start
	1431		n2= end - round(self.end_data_ele)
	1432		print(self.start_data_ele)
	1433		print(self.end_data_ele)
	1434		if n1>0:
	1435		ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	1436		ele1_nan= numpy.ones(n1)*numpy.nan
	1437		data_ele = numpy.hstack((ele1,data_ele_new))
	1438		print("ele1_nan",ele1_nan.shape)
	1439		print("data_ele_old",data_ele_old.shape)
	1440		data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	1441		if n2>0:
	1442		ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	1443		ele2_nan= numpy.ones(n2)*numpy.nan
	1444		data_ele = numpy.hstack((data_ele,ele2))
	1445		print("ele2_nan",ele2_nan.shape)
	1446		print("data_ele_old",data_ele_old.shape)
	1447		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1448
	1449		if tipo_case==1 or tipo_case==2: # BAJADA
	1450		data_ele_new = data_ele_new[::-1] # reversa
	1451		data_ele_old = data_ele_old[::-1]# reversa
	1452		data_weather = data_weather[::-1,:]# reversa
	1453		vec= numpy.where(data_ele_new<ang_max)
	1454		data_ele_new = data_ele_new[vec]
	1455		data_ele_old = data_ele_old[vec]
	1456		data_weather = data_weather[vec[0]]
	1457		vec2= numpy.where(0<data_ele_new)
	1458		data_ele_new = data_ele_new[vec2]
	1459		data_ele_old = data_ele_old[vec2]
	1460		data_weather = data_weather[vec2[0]]
	1461		self.start_data_ele = data_ele_new[0]
	1462		self.end_data_ele = data_ele_new[-1]
	1463
	1464		n1= round(self.start_data_ele)- start
	1465		n2= end - round(self.end_data_ele)-1
	1466		print(self.start_data_ele)
	1467		print(self.end_data_ele)
	1468		if n1>0:
	1469		ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
	1470		ele1_nan= numpy.ones(n1)*numpy.nan
	1471		data_ele = numpy.hstack((ele1,data_ele_new))
	1472		data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
	1473		if n2>0:
	1474		ele2= numpy.linspace(self.end_data_ele+1,end,n2)
	1475		ele2_nan= numpy.ones(n2)*numpy.nan
	1476		data_ele = numpy.hstack((data_ele,ele2))
	1477		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1478		# RADAR
	1479		# NOTA data_ele y data_weather es la variable que retorna
	1480		val_mean = numpy.mean(data_weather[:,-1])
	1481		self.val_mean = val_mean
	1482		data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1483		print("eleold",data_ele_old)
	1484		print(self.data_ele_tmp[val_ch])
	1485		print(data_ele_old.shape[0])
	1486		print(self.data_ele_tmp[val_ch].shape[0])
	1487		if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
	1488		import sys
	1489		print("EXIT",self.ini)
	1490
	1491		sys.exit(1)
	1492		self.data_ele_tmp[val_ch]= data_ele_old
	1493		else:
	1494		#print("**********************************************")
	1495		#print("**************VARIABLE********************")
	1496		#-------------------------CAMBIOS RHI---------------------------------
	1497		#---------------------------------------------------------------------
	1498		##print("INPUT data_ele",data_ele)
	1499		flag=0
	1500		start_ele = self.res_ele[0]
	1501		#tipo_case = self.check_case(data_ele,ang_max,ang_min)
	1502		tipo_case = case_flag[-1]
	1503		#print("TIPO DE DATA",tipo_case)
	1504		#-----------new------------
	1505		data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
	1506		data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1507
	1508		#-------------------------------NEW RHI ITERATIVO-------------------------
	1509
	1510		if tipo_case==0 : # SUBIDA
	1511		vec = numpy.where(data_ele<ang_max)
	1512		data_ele = data_ele[vec]
	1513		data_ele_old = data_ele_old[vec]
	1514		data_weather = data_weather[vec[0]]
	1515
	1516		vec2 = numpy.where(0<data_ele)
	1517		data_ele= data_ele[vec2]
	1518		data_ele_old= data_ele_old[vec2]
	1519		##print(data_ele_new)
	1520		data_weather= data_weather[vec2[0]]
	1521
	1522		new_i_ele = int(round(data_ele[0]))
	1523		new_f_ele = int(round(data_ele[-1]))
	1524		#print(new_i_ele)
	1525		#print(new_f_ele)
	1526		#print(data_ele,len(data_ele))
	1527		#print(data_ele_old,len(data_ele_old))
	1528		if new_i_ele< 2:
	1529		self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	1530		self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	1531		self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
	1532		self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
	1533		self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
	1534		data_ele = self.res_ele
	1535		data_weather = self.res_weather[val_ch]
	1536
	1537		elif tipo_case==1 : #BAJADA
	1538		data_ele = data_ele[::-1] # reversa
	1539		data_ele_old = data_ele_old[::-1]# reversa
	1540		data_weather = data_weather[::-1,:]# reversa
	1541		vec= numpy.where(data_ele<ang_max)
	1542		data_ele = data_ele[vec]
	1543		data_ele_old = data_ele_old[vec]
	1544		data_weather = data_weather[vec[0]]
	1545		vec2= numpy.where(0<data_ele)
	1546		data_ele = data_ele[vec2]
	1547		data_ele_old = data_ele_old[vec2]
	1548		data_weather = data_weather[vec2[0]]
	1549
	1550
	1551		new_i_ele = int(round(data_ele[0]))
	1552		new_f_ele = int(round(data_ele[-1]))
	1553		#print(data_ele)
	1554		#print(ang_max)
	1555		#print(data_ele_old)
	1556		if new_i_ele <= 1:
	1557		new_i_ele = 1
	1558		if round(data_ele[-1])>=ang_max-1:
	1559		self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
	1560		self.res_weather[val_ch] = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
	1561		self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
	1562		self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
	1563		self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
	1564		data_ele = self.res_ele
	1565		data_weather = self.res_weather[val_ch]
	1566
	1567		elif tipo_case==2: #bajada
	1568		vec = numpy.where(data_ele<ang_max)
	1569		data_ele = data_ele[vec]
	1570		data_weather= data_weather[vec[0]]
	1571
	1572		len_vec = len(vec)
	1573		data_ele_new = data_ele[::-1] # reversa
	1574		data_weather = data_weather[::-1,:]
	1575		new_i_ele = int(data_ele_new[0])
	1576		new_f_ele = int(data_ele_new[-1])
	1577
	1578		n1= new_i_ele- ang_min
	1579		n2= ang_max - new_f_ele-1
	1580		if n1>0:
	1581		ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1582		ele1_nan= numpy.ones(n1)*numpy.nan
	1583		data_ele = numpy.hstack((ele1,data_ele_new))
	1584		data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1585		if n2>0:
	1586		ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1587		ele2_nan= numpy.ones(n2)*numpy.nan
	1588		data_ele = numpy.hstack((data_ele,ele2))
	1589		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1590
	1591		self.data_ele_tmp[val_ch] = data_ele_old
	1592		self.res_ele = data_ele
	1593		self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1594		data_ele = self.res_ele
	1595		data_weather = self.res_weather[val_ch]
	1596
	1597		elif tipo_case==3:#subida
	1598		vec = numpy.where(0<data_ele)
	1599		data_ele= data_ele[vec]
	1600		data_ele_new = data_ele
	1601		data_ele_old= data_ele_old[vec]
	1602		data_weather= data_weather[vec[0]]
	1603		pos_ini = numpy.argmin(data_ele)
	1604		if pos_ini>0:
	1605		len_vec= len(data_ele)
	1606		vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
	1607		#print(vec3)
	1608		data_ele= data_ele[vec3]
	1609		data_ele_new = data_ele
	1610		data_ele_old= data_ele_old[vec3]
	1611		data_weather= data_weather[vec3]
	1612
	1613		new_i_ele = int(data_ele_new[0])
	1614		new_f_ele = int(data_ele_new[-1])
	1615		n1= new_i_ele- ang_min
	1616		n2= ang_max - new_f_ele-1
	1617		if n1>0:
	1618		ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
	1619		ele1_nan= numpy.ones(n1)*numpy.nan
	1620		data_ele = numpy.hstack((ele1,data_ele_new))
	1621		data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
	1622		if n2>0:
	1623		ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
	1624		ele2_nan= numpy.ones(n2)*numpy.nan
	1625		data_ele = numpy.hstack((data_ele,ele2))
	1626		data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
	1627
	1628		self.data_ele_tmp[val_ch] = data_ele_old
	1629		self.res_ele = data_ele
	1630		self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
	1631		data_ele = self.res_ele
	1632		data_weather = self.res_weather[val_ch]
	1633		#print("self.data_ele_tmp",self.data_ele_tmp)
	1634		return data_weather,data_ele
	1635
	1636
	1637		def plot(self):
	1638		thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
	1639		data = self.data[-1]
	1640		r = self.data.yrange
	1641		delta_height = r[1]-r[0]
	1642		r_mask = numpy.where(r>=0)[0]
	1643		##print("delta_height",delta_height)
	1644		#print("r_mask",r_mask,len(r_mask))
	1645		r = numpy.arange(len(r_mask))*delta_height
	1646		self.y = 2*r
	1647		res = 1
	1648		###print("data['weather'].shape[0]",data['weather'].shape[0])
	1649		ang_max = self.ang_max
	1650		ang_min = self.ang_min
	1651		var_ang =ang_max - ang_min
	1652		step = (int(var_ang)/(res*data['weather'].shape[0]))
	1653		###print("step",step)
	1654		#--------------------------------------------------------
	1655		##print('weather',data['weather'].shape)
	1656		##print('ele',data['ele'].shape)
	1657
	1658		###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)
	1659		###self.res_azi = numpy.mean(data['azi'])
	1660		###print("self.res_ele",self.res_ele)
	1661		plt.clf()
	1662		subplots = [121, 122]
	1663		try:
	1664		if self.data[-2]['ele'].max()<data['ele'].max():
	1665		self.ini=0
	1666		except:
	1667		pass
	1668		if self.ini==0:
	1669		self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
	1670		self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
	1671		print("SHAPE",self.data_ele_tmp.shape)
	1672
	1673		for i,ax in enumerate(self.axes):
	1674		self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
	1675		self.res_azi = numpy.mean(data['azi'])
	1676
	1677		if ax.firsttime:
	1678		#plt.clf()
	1679		print("Frist Plot")
	1680		cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
	1681		#fig=self.figures[0]
	1682		else:
	1683		#plt.clf()
	1684		print("ELSE PLOT")
	1685		cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
	1686		caax = cgax.parasites[0]
	1687		paax = cgax.parasites[1]
	1688		cbar = plt.gcf().colorbar(pm, pad=0.075)
	1689		caax.set_xlabel('x_range [km]')
	1690		caax.set_ylabel('y_range [km]')
	1691		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')
	1692		print("*************************self.ini**************************",self.ini)
	1693		self.ini= self.ini+1
	1694
	1695
	1696
	1697
	1698
	1699		class WeatherRHI_vRF4_Plot(Plot):
	1700		CODE = 'RHI'
	1701		plot_name = 'RHI'
	1702		#plot_type = 'rhistyle'
	1703		buffering = False
	1704
	1705		def setup(self):
	1706
	1707		self.ncols = 1
	1708		self.nrows = 1
	1709		self.nplots= 1
	1710		self.ylabel= 'Range [Km]'
	1711		self.xlabel= 'Range [Km]'
	1712		self.titles= ['RHI']
	1713		self.polar = True
	1714		self.grid = True
	1715		if self.channels is not None:
	1716		self.nplots = len(self.channels)
	1717		self.nrows = len(self.channels)
	1718		else:
	1719		self.nplots = self.data.shape(self.CODE)[0]
	1720		self.nrows = self.nplots
	1721		self.channels = list(range(self.nplots))
	1722
	1723		if self.CODE == 'Power':
	1724		self.cb_label = r'Power (dB)'
	1725		elif self.CODE == 'Doppler':
	1726		self.cb_label = r'Velocity (m/s)'
	1727		self.colorbar=True
	1728		self.width =8
	1729		self.height =8
	1730		self.ini =0
	1731		self.len_azi =0
	1732		self.buffer_ini = None
	1733		self.buffer_ele = None
	1734		self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
	1735		self.flag =0
	1736		self.indicador= 0
	1737		self.last_data_ele = None
	1738		self.val_mean = None
	1739
	1740		def update(self, dataOut):
	1741
	1742		data = {}
	1743		meta = {}
	1744		if hasattr(dataOut, 'dataPP_POWER'):
	1745		factor = 1
	1746		if hasattr(dataOut, 'nFFTPoints'):
	1747		factor = dataOut.normFactor
	1748
	1749		if 'pow' in self.attr_data[0].lower():
	1750		data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
	1751		else:
	1752		data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
	1753
	1754		data['azi'] = dataOut.data_azi
	1755		data['ele'] = dataOut.data_ele
	1756
	1757		return data, meta
	1758
	1759		def plot(self):
	1760		data = self.data[-1]
	1761		r = self.data.yrange
	1762		delta_height = r[1]-r[0]
	1763		r_mask = numpy.where(r>=0)[0]
	1764		self.r_mask =r_mask
	1765		r = numpy.arange(len(r_mask))*delta_height
	1766		self.y = 2*r
	1767
	1768		try:
	1769		z = data['data'][self.channels[0]][:,r_mask]
	1770		except:
	1771		z = data['data'][0][:,r_mask]
	1772
	1773		self.titles = []
	1774
	1775		self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
	1776		self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1777		self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1778		self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1779		self.ang_min = self.ang_min if self.ang_min else 0
	1780		self.ang_max = self.ang_max if self.ang_max else 90
	1781
	1782		r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
	1783
	1784		for i,ax in enumerate(self.axes):
	1785
	1786		if ax.firsttime:
	1787		ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1788		ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1789
	1790		else:
	1791		ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
	1792		ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
	1793		ax.grid(True)
	1794		if len(self.channels) !=1:
	1795		self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]
	1796		else:
	1797		self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]
	1798
	1799	372	class WeatherParamsPlot(Plot):
	1800	373	#CODE = 'RHI'
	1801	374	#plot_name = 'RHI'
			@@ -1879,7 +452,7 class WeatherParamsPlot(Plot):
	1879	452	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1880	453	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1881	454	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	1882		print("mode inside plot",self.data['mode_op'],data['mode_op'])
		455
	1883	456	if data['mode_op'] == 'RHI':
	1884	457	try:
	1885	458	if self.data['mode_op'][-2] == 'PPI':
			@@ -1924,13 +497,13 class WeatherParamsPlot(Plot):
	1924	497	len_aux = int(data['azi'].shape[0]/4)
	1925	498	mean = numpy.mean(data['azi'][len_aux:-len_aux])
	1926	499	if len(self.channels) !=1:
	1927		self.titles = ['RHI {} at AZ: {} C~~hannel~~ {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
		500	self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
	1928	501	else:
	1929		self.titles = ['RHI {} at AZ: {} C~~hannel~~ {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
		502	self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
	1930	503	elif data['mode_op'] == 'PPI':
	1931	504	len_aux = int(data['ele'].shape[0]/4)
	1932	505	mean = numpy.mean(data['ele'][len_aux:-len_aux])
	1933	506	if len(self.channels) !=1:
	1934		self.titles = ['PPI {} at EL: {} C~~hannel~~ {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
		507	self.titles = ['PPI {} at EL: {} CH {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
	1935	508	else:
	1936		self.titles = ['PPI {} at EL: {} C~~hannel~~ {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
		509	self.titles = ['PPI {} at EL: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]

schainpy/model/proc/jroproc_parameters.py +7 -683

This diff has been collapsed as it changes many lines, (690 lines changed) Show them Hide them
			@@ -4267,681 +4267,8 class PedestalInformation(Operation):
	4267	4267
	4268	4268	return dataOut
	4269	4269
	4270		class Block360(Operation):
	4271		'''
	4272		'''
	4273		isConfig = False
	4274		__profIndex = 0
	4275		__initime = None
	4276		__lastdatatime = None
	4277		__buffer = None
	4278		__dataReady = False
	4279		n = None
	4280		__nch = 0
	4281		__nHeis = 0
	4282		index = 0
	4283		mode = 0
	4284
	4285		def __init__(self,**kwargs):
	4286		Operation.__init__(self,**kwargs)
	4287
	4288		def setup(self, dataOut, n = None, mode = None):
	4289		'''
	4290		n= Numero de PRF's de entrada
	4291		'''
	4292		self.__initime = None
	4293		self.__lastdatatime = 0
	4294		self.__dataReady = False
	4295		self.__buffer = 0
	4296		self.__buffer_1D = 0
	4297		self.__profIndex = 0
	4298		self.index = 0
	4299		self.__nch = dataOut.nChannels
	4300		self.__nHeis = dataOut.nHeights
	4301		##print("ELVALOR DE n es:", n)
	4302		if n == None:
	4303		raise ValueError("n should be specified.")
	4304
	4305		if mode == None:
	4306		raise ValueError("mode should be specified.")
	4307
	4308		if n != None:
	4309		if n<1:
	4310		print("n should be greater than 2")
	4311		raise ValueError("n should be greater than 2")
	4312
	4313		self.n = n
	4314		self.mode = mode
	4315		#print("self.mode",self.mode)
	4316		#print("nHeights")
	4317		self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights))
	4318		self.__buffer2 = numpy.zeros(n)
	4319		self.__buffer3 = numpy.zeros(n)
	4320
	4321
	4322
	4323
	4324		def putData(self,data,mode):
	4325		'''
	4326		Add a profile to he __buffer and increase in one the __profiel Index
	4327		'''
	4328		#print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10])
	4329		#print("line 4049",data.azimuth.shape,data.azimuth)
	4330		if self.mode==0:
	4331		self.__buffer[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO
	4332		if self.mode==1:
	4333		self.__buffer[:,self.__profIndex,:]= data.data_pow
	4334		#print("me casi",self.index,data.azimuth[self.index])
	4335		#print(self.__profIndex, self.index , data.azimuth[self.index] )
	4336		#print("magic",data.profileIndex)
	4337		#print(data.azimuth[self.index])
	4338		#print("index",self.index)
	4339
	4340		#####self.__buffer2[self.__profIndex] = data.azimuth[self.index]
	4341		self.__buffer2[self.__profIndex] = data.azimuth
	4342		self.__buffer3[self.__profIndex] = data.elevation
	4343		#print("q pasa")
	4344		#####self.index+=1
	4345		#print("index",self.index,data.azimuth[:10])
	4346		self.__profIndex += 1
	4347		return #················· Remove DC···································
	4348
	4349		def pushData(self,data):
	4350		'''
	4351		Return the PULSEPAIR and the profiles used in the operation
	4352		Affected : self.__profileIndex
	4353		'''
	4354		#print("pushData")
	4355
	4356		data_360 = self.__buffer
	4357		data_p = self.__buffer2
	4358		data_e = self.__buffer3
	4359		n = self.__profIndex
	4360
	4361		self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis))
	4362		self.__buffer2 = numpy.zeros(self.n)
	4363		self.__buffer3 = numpy.zeros(self.n)
	4364		self.__profIndex = 0
	4365		#print("pushData")
	4366		return data_360,n,data_p,data_e
	4367
	4368
	4369		def byProfiles(self,dataOut):
	4370
	4371		self.__dataReady = False
	4372		data_360 = None
	4373		data_p = None
	4374		data_e = None
	4375		#print("dataOu",dataOut.dataPP_POW)
	4376		self.putData(data=dataOut,mode = self.mode)
	4377		##### print("profIndex",self.__profIndex)
	4378		if self.__profIndex == self.n:
	4379		data_360,n,data_p,data_e = self.pushData(data=dataOut)
	4380		self.__dataReady = True
	4381
	4382		return data_360,data_p,data_e
	4383
	4384
	4385		def blockOp(self, dataOut, datatime= None):
	4386		if self.__initime == None:
	4387		self.__initime = datatime
	4388		data_360,data_p,data_e = self.byProfiles(dataOut)
	4389		self.__lastdatatime = datatime
	4390
	4391		if data_360 is None:
	4392		return None, None,None,None
	4393
	4394
	4395		avgdatatime = self.__initime
	4396		if self.n==1:
	4397		avgdatatime = datatime
	4398		deltatime = datatime - self.__lastdatatime
	4399		self.__initime = datatime
	4400		#print(data_360.shape,avgdatatime,data_p.shape)
	4401		return data_360,avgdatatime,data_p,data_e
	4402
	4403		def run(self, dataOut,n = None,mode=None,**kwargs):
	4404		#print("BLOCK 360 HERE WE GO MOMENTOS")
	4405		print("Block 360")
	4406		#exit(1)
	4407		if not self.isConfig:
	4408		self.setup(dataOut = dataOut, n = n ,mode= mode ,**kwargs)
	4409		####self.index = 0
	4410		#print("comova",self.isConfig)
	4411		self.isConfig = True
	4412		####if self.index==dataOut.azimuth.shape[0]:
	4413		#### self.index=0
	4414		data_360, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime)
	4415		dataOut.flagNoData = True
	4416
	4417		if self.__dataReady:
	4418		dataOut.data_360 = data_360 # S
	4419		#print("DATA 360")
	4420		#print(dataOut.data_360)
	4421		#print("---------------------------------------------------------------------------------")
	4422		print("---------------------------DATAREADY---------------------------------------------")
	4423		#print("---------------------------------------------------------------------------------")
	4424		#print("data_360",dataOut.data_360.shape)
	4425		dataOut.data_azi = data_p
	4426		dataOut.data_ele = data_e
	4427		###print("azi: ",dataOut.data_azi)
	4428		#print("ele: ",dataOut.data_ele)
	4429		#print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime)
	4430		dataOut.utctime = avgdatatime
	4431		dataOut.flagNoData = False
	4432		return dataOut
	4433
	4434		class Block360_vRF(Operation):
	4435		'''
	4436		'''
	4437		isConfig = False
	4438		__profIndex = 0
	4439		__initime = None
	4440		__lastdatatime = None
	4441		__buffer = None
	4442		__dataReady = False
	4443		n = None
	4444		__nch = 0
	4445		__nHeis = 0
	4446		index = 0
	4447		mode = 0
	4448
	4449		def __init__(self,**kwargs):
	4450		Operation.__init__(self,**kwargs)
	4451
	4452		def setup(self, dataOut, n = None, mode = None):
	4453		'''
	4454		n= Numero de PRF's de entrada
	4455		'''
	4456		self.__initime = None
	4457		self.__lastdatatime = 0
	4458		self.__dataReady = False
	4459		self.__buffer = 0
	4460		self.__buffer_1D = 0
	4461		self.__profIndex = 0
	4462		self.index = 0
	4463		self.__nch = dataOut.nChannels
	4464		self.__nHeis = dataOut.nHeights
	4465		##print("ELVALOR DE n es:", n)
	4466		if n == None:
	4467		raise ValueError("n should be specified.")
	4468
	4469		if mode == None:
	4470		raise ValueError("mode should be specified.")
	4471
	4472		if n != None:
	4473		if n<1:
	4474		print("n should be greater than 2")
	4475		raise ValueError("n should be greater than 2")
	4476
	4477		self.n = n
	4478		self.mode = mode
	4479		#print("self.mode",self.mode)
	4480		#print("nHeights")
	4481		self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights))
	4482		self.__buffer2 = numpy.zeros(n)
	4483		self.__buffer3 = numpy.zeros(n)
	4484
	4485
	4486
	4487
	4488		def putData(self,data,mode):
	4489		'''
	4490		Add a profile to he __buffer and increase in one the __profiel Index
	4491		'''
	4492		#print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10])
	4493		#print("line 4049",data.azimuth.shape,data.azimuth)
	4494		if self.mode==0:
	4495		self.__buffer[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO
	4496		if self.mode==1:
	4497		self.__buffer[:,self.__profIndex,:]= data.data_pow
	4498		#print("me casi",self.index,data.azimuth[self.index])
	4499		#print(self.__profIndex, self.index , data.azimuth[self.index] )
	4500		#print("magic",data.profileIndex)
	4501		#print(data.azimuth[self.index])
	4502		#print("index",self.index)
	4503
	4504		#####self.__buffer2[self.__profIndex] = data.azimuth[self.index]
	4505		self.__buffer2[self.__profIndex] = data.azimuth
	4506		self.__buffer3[self.__profIndex] = data.elevation
	4507		#print("q pasa")
	4508		#####self.index+=1
	4509		#print("index",self.index,data.azimuth[:10])
	4510		self.__profIndex += 1
	4511		return #················· Remove DC···································
	4512
	4513		def pushData(self,data):
	4514		'''
	4515		Return the PULSEPAIR and the profiles used in the operation
	4516		Affected : self.__profileIndex
	4517		'''
	4518		#print("pushData")
	4519
	4520		data_360 = self.__buffer
	4521		data_p = self.__buffer2
	4522		data_e = self.__buffer3
	4523		n = self.__profIndex
	4524
	4525		self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis))
	4526		self.__buffer2 = numpy.zeros(self.n)
	4527		self.__buffer3 = numpy.zeros(self.n)
	4528		self.__profIndex = 0
	4529		#print("pushData")
	4530		return data_360,n,data_p,data_e
	4531
	4532
	4533		def byProfiles(self,dataOut):
	4534
	4535		self.__dataReady = False
	4536		data_360 = None
	4537		data_p = None
	4538		data_e = None
	4539		#print("dataOu",dataOut.dataPP_POW)
	4540		self.putData(data=dataOut,mode = self.mode)
	4541		##### print("profIndex",self.__profIndex)
	4542		if self.__profIndex == self.n:
	4543		data_360,n,data_p,data_e = self.pushData(data=dataOut)
	4544		self.__dataReady = True
	4545
	4546		return data_360,data_p,data_e
	4547
	4548
	4549		def blockOp(self, dataOut, datatime= None):
	4550		if self.__initime == None:
	4551		self.__initime = datatime
	4552		data_360,data_p,data_e = self.byProfiles(dataOut)
	4553		self.__lastdatatime = datatime
	4554
	4555		if data_360 is None:
	4556		return None, None,None,None
	4557
	4558
	4559		avgdatatime = self.__initime
	4560		if self.n==1:
	4561		avgdatatime = datatime
	4562		deltatime = datatime - self.__lastdatatime
	4563		self.__initime = datatime
	4564		#print(data_360.shape,avgdatatime,data_p.shape)
	4565		return data_360,avgdatatime,data_p,data_e
	4566	4270
	4567		def checkcase(self,data_ele):
	4568		start = data_ele[0]
	4569		end = data_ele[-1]
	4570		diff_angle = (end-start)
	4571		len_ang=len(data_ele)
	4572		print("start",start)
	4573		print("end",end)
	4574		print("number",diff_angle)
	4575
	4576		print("len_ang",len_ang)
	4577
	4578		aux = (data_ele<0).any(axis=0)
	4579
	4580		#exit(1)
	4581		if diff_angle<0 and aux!=1: #Bajada
	4582		return 1
	4583		elif diff_angle<0 and aux==1: #Bajada con angulos negativos
	4584		return 0
	4585		elif diff_angle == 0: # This case happens when the angle reaches the max_angle if n = 2
	4586		self.flagEraseFirstData = 1
	4587		print("ToDO this case")
	4588		exit(1)
	4589		elif diff_angle>0: #Subida
	4590		return 0
	4591
	4592		def run(self, dataOut,n = None,mode=None,**kwargs):
	4593		#print("BLOCK 360 HERE WE GO MOMENTOS")
	4594		print("Block 360")
	4595
	4596		#exit(1)
	4597		if not self.isConfig:
	4598		if n == 1:
	4599		print("*****************Min Value is 2. Setting n = 2*****************")
	4600		n = 2
	4601		#exit(1)
	4602		print(n)
	4603		self.setup(dataOut = dataOut, n = n ,mode= mode ,**kwargs)
	4604		####self.index = 0
	4605		#print("comova",self.isConfig)
	4606		self.isConfig = True
	4607		####if self.index==dataOut.azimuth.shape[0]:
	4608		#### self.index=0
	4609		data_360, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime)
	4610		dataOut.flagNoData = True
	4611
	4612		if self.__dataReady:
	4613		dataOut.data_360 = data_360 # S
	4614		#print("DATA 360")
	4615		#print(dataOut.data_360)
	4616		#print("---------------------------------------------------------------------------------")
	4617		print("---------------------------DATAREADY---------------------------------------------")
	4618		#print("---------------------------------------------------------------------------------")
	4619		#print("data_360",dataOut.data_360.shape)
	4620		dataOut.data_azi = data_p
	4621		dataOut.data_ele = data_e
	4622		###print("azi: ",dataOut.data_azi)
	4623		#print("ele: ",dataOut.data_ele)
	4624		#print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime)
	4625		dataOut.utctime = avgdatatime
	4626
	4627		dataOut.case_flag = self.checkcase(dataOut.data_ele)
	4628		if dataOut.case_flag: #Si está de bajada empieza a plotear
	4629		print("INSIDE CASE FLAG BAJADA")
	4630		dataOut.flagNoData = False
	4631		else:
	4632		print("CASE SUBIDA")
	4633		dataOut.flagNoData = True
	4634
	4635		#dataOut.flagNoData = False
	4636		return dataOut
	4637
	4638		class Block360_vRF2(Operation):
	4639		'''
	4640		'''
	4641		isConfig = False
	4642		__profIndex = 0
	4643		__initime = None
	4644		__lastdatatime = None
	4645		__buffer = None
	4646		__dataReady = False
	4647		n = None
	4648		__nch = 0
	4649		__nHeis = 0
	4650		index = 0
	4651		mode = None
	4652
	4653		def __init__(self,**kwargs):
	4654		Operation.__init__(self,**kwargs)
	4655
	4656		def setup(self, dataOut, n = None, mode = None):
	4657		'''
	4658		n= Numero de PRF's de entrada
	4659		'''
	4660		self.__initime = None
	4661		self.__lastdatatime = 0
	4662		self.__dataReady = False
	4663		self.__buffer = 0
	4664		self.__buffer_1D = 0
	4665		#self.__profIndex = 0
	4666		self.index = 0
	4667		self.__nch = dataOut.nChannels
	4668		self.__nHeis = dataOut.nHeights
	4669
	4670		self.mode = mode
	4671		#print("self.mode",self.mode)
	4672		#print("nHeights")
	4673		self.__buffer = []
	4674		self.__buffer2 = []
	4675		self.__buffer3 = []
	4676		self.__buffer4 = []
	4677
	4678		def putData(self,data,mode):
	4679		'''
	4680		Add a profile to he __buffer and increase in one the __profiel Index
	4681		'''
	4682
	4683		if self.mode==0:
	4684		self.__buffer.append(data.dataPP_POWER)# PRIMER MOMENTO
	4685		if self.mode==1:
	4686		self.__buffer.append(data.data_pow)
	4687
	4688		self.__buffer4.append(data.dataPP_DOP)
	4689
	4690		self.__buffer2.append(data.azimuth)
	4691		self.__buffer3.append(data.elevation)
	4692		self.__profIndex += 1
	4693
	4694		return numpy.array(self.__buffer3) #················· Remove DC···································
	4695
	4696		def pushData(self,data):
	4697		'''
	4698		Return the PULSEPAIR and the profiles used in the operation
	4699		Affected : self.__profileIndex
	4700		'''
	4701
	4702		data_360_Power = numpy.array(self.__buffer).transpose(1,0,2)
	4703		data_360_Velocity = numpy.array(self.__buffer4).transpose(1,0,2)
	4704		data_p = numpy.array(self.__buffer2)
	4705		data_e = numpy.array(self.__buffer3)
	4706		n = self.__profIndex
	4707
	4708		self.__buffer = []
	4709		self.__buffer4 = []
	4710		self.__buffer2 = []
	4711		self.__buffer3 = []
	4712		self.__profIndex = 0
	4713		return data_360_Power,data_360_Velocity,n,data_p,data_e
	4714
	4715
	4716		def byProfiles(self,dataOut):
	4717
	4718		self.__dataReady = False
	4719		data_360_Power = []
	4720		data_360_Velocity = []
	4721		data_p = None
	4722		data_e = None
	4723
	4724		elevations = self.putData(data=dataOut,mode = self.mode)
	4725
	4726		if self.__profIndex > 1:
	4727		case_flag = self.checkcase(elevations)
	4728
	4729		if case_flag == 0: #Subida
	4730
	4731		if len(self.__buffer) == 2: #Cuando está de subida
	4732		#Se borra el dato anterior para liberar buffer y comparar el dato actual con el siguiente
	4733		self.__buffer.pop(0) #Erase first data
	4734		self.__buffer2.pop(0)
	4735		self.__buffer3.pop(0)
	4736		self.__buffer4.pop(0)
	4737		self.__profIndex -= 1
	4738		else: #Cuando ha estado de bajada y ha vuelto a subir
	4739		#Se borra el último dato
	4740		self.__buffer.pop() #Erase last data
	4741		self.__buffer2.pop()
	4742		self.__buffer3.pop()
	4743		self.__buffer4.pop()
	4744		data_360_Power,data_360_Velocity,n,data_p,data_e = self.pushData(data=dataOut)
	4745
	4746		self.__dataReady = True
	4747
	4748		return data_360_Power,data_360_Velocity,data_p,data_e
	4749
	4750
	4751		def blockOp(self, dataOut, datatime= None):
	4752		if self.__initime == None:
	4753		self.__initime = datatime
	4754		data_360_Power,data_360_Velocity,data_p,data_e = self.byProfiles(dataOut)
	4755		self.__lastdatatime = datatime
	4756
	4757		avgdatatime = self.__initime
	4758		if self.n==1:
	4759		avgdatatime = datatime
	4760		deltatime = datatime - self.__lastdatatime
	4761		self.__initime = datatime
	4762		return data_360_Power,data_360_Velocity,avgdatatime,data_p,data_e
	4763
	4764		def checkcase(self,data_ele):
	4765		#print(data_ele)
	4766		start = data_ele[-2]
	4767		end = data_ele[-1]
	4768		diff_angle = (end-start)
	4769		len_ang=len(data_ele)
	4770
	4771		if diff_angle > 0: #Subida
	4772		return 0
	4773
	4774		def run(self, dataOut,mode='Power',**kwargs):
	4775		#print("BLOCK 360 HERE WE GO MOMENTOS")
	4776		#print("Block 360")
	4777		dataOut.mode = mode
	4778
	4779		if not self.isConfig:
	4780		self.setup(dataOut = dataOut ,mode= mode ,**kwargs)
	4781		self.isConfig = True
	4782
	4783
	4784		data_360_Power, data_360_Velocity, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime)
	4785
	4786
	4787		dataOut.flagNoData = True
	4788
	4789
	4790		if self.__dataReady:
	4791		dataOut.data_360_Power = data_360_Power # S
	4792		dataOut.data_360_Velocity = data_360_Velocity
	4793		dataOut.data_azi = data_p
	4794		dataOut.data_ele = data_e
	4795		dataOut.utctime = avgdatatime
	4796		dataOut.flagNoData = False
	4797
	4798		return dataOut
	4799
	4800		class Block360_vRF3(Operation):
	4801		'''
	4802		'''
	4803		isConfig = False
	4804		__profIndex = 0
	4805		__initime = None
	4806		__lastdatatime = None
	4807		__buffer = None
	4808		__dataReady = False
	4809		n = None
	4810		__nch = 0
	4811		__nHeis = 0
	4812		index = 0
	4813		mode = None
	4814
	4815		def __init__(self,**kwargs):
	4816		Operation.__init__(self,**kwargs)
	4817
	4818		def setup(self, dataOut, attr):
	4819		'''
	4820		n= Numero de PRF's de entrada
	4821		'''
	4822		self.__initime = None
	4823		self.__lastdatatime = 0
	4824		self.__dataReady = False
	4825		self.__buffer = 0
	4826		self.__buffer_1D = 0
	4827		self.index = 0
	4828		self.__nch = dataOut.nChannels
	4829		self.__nHeis = dataOut.nHeights
	4830
	4831		self.attr = attr
	4832		#print("self.mode",self.mode)
	4833		#print("nHeights")
	4834		self.__buffer = []
	4835		self.__buffer2 = []
	4836		self.__buffer3 = []
	4837
	4838		def putData(self, data, attr):
	4839		'''
	4840		Add a profile to he __buffer and increase in one the __profiel Index
	4841		'''
	4842
	4843		self.__buffer.append(getattr(data, attr))
	4844		self.__buffer2.append(data.azimuth)
	4845		self.__buffer3.append(data.elevation)
	4846		self.__profIndex += 1
	4847
	4848		return numpy.array(self.__buffer3)
	4849
	4850		def pushData(self, data):
	4851		'''
	4852		Return the PULSEPAIR and the profiles used in the operation
	4853		Affected : self.__profileIndex
	4854		'''
	4855
	4856		data_360 = numpy.array(self.__buffer).transpose(1, 0, 2)
	4857		data_p = numpy.array(self.__buffer2)
	4858		data_e = numpy.array(self.__buffer3)
	4859		n = self.__profIndex
	4860
	4861		self.__buffer = []
	4862		self.__buffer2 = []
	4863		self.__buffer3 = []
	4864		self.__profIndex = 0
	4865		return data_360, n, data_p, data_e
	4866
	4867
	4868		def byProfiles(self,dataOut):
	4869
	4870		self.__dataReady = False
	4871		data_360 = []
	4872		data_p = None
	4873		data_e = None
	4874
	4875		elevations = self.putData(data=dataOut, attr = self.attr)
	4876
	4877		if self.__profIndex > 1:
	4878		case_flag = self.checkcase(elevations)
	4879
	4880		if case_flag == 0: #Subida
	4881
	4882		if len(self.__buffer) == 2: #Cuando está de subida
	4883		#Se borra el dato anterior para liberar buffer y comparar el dato actual con el siguiente
	4884		self.__buffer.pop(0) #Erase first data
	4885		self.__buffer2.pop(0)
	4886		self.__buffer3.pop(0)
	4887		self.__profIndex -= 1
	4888		else: #Cuando ha estado de bajada y ha vuelto a subir
	4889		#Se borra el último dato
	4890		self.__buffer.pop() #Erase last data
	4891		self.__buffer2.pop()
	4892		self.__buffer3.pop()
	4893		data_360, n, data_p, data_e = self.pushData(data=dataOut)
	4894
	4895		self.__dataReady = True
	4896
	4897		return data_360, data_p, data_e
	4898
	4899
	4900		def blockOp(self, dataOut, datatime= None):
	4901		if self.__initime == None:
	4902		self.__initime = datatime
	4903		data_360, data_p, data_e = self.byProfiles(dataOut)
	4904		self.__lastdatatime = datatime
	4905
	4906		avgdatatime = self.__initime
	4907		if self.n==1:
	4908		avgdatatime = datatime
	4909		deltatime = datatime - self.__lastdatatime
	4910		self.__initime = datatime
	4911		return data_360, avgdatatime, data_p, data_e
	4912
	4913		def checkcase(self, data_ele):
	4914
	4915		start = data_ele[-2]
	4916		end = data_ele[-1]
	4917		diff_angle = (end-start)
	4918		len_ang=len(data_ele)
	4919
	4920		if diff_angle > 0: #Subida
	4921		return 0
	4922
	4923		def run(self, dataOut, attr_data='dataPP_POWER',**kwargs):
	4924
	4925		dataOut.attr_data = attr_data
	4926
	4927		if not self.isConfig:
	4928		self.setup(dataOut = dataOut, attr = attr_data ,**kwargs)
	4929		self.isConfig = True
	4930
	4931		data_360, avgdatatime, data_p, data_e = self.blockOp(dataOut, dataOut.utctime)
	4932
	4933		dataOut.flagNoData = True
	4934
	4935		if self.__dataReady:
	4936		setattr(dataOut, attr_data, data_360 )
	4937		dataOut.data_azi = data_p
	4938		dataOut.data_ele = data_e
	4939		dataOut.utctime = avgdatatime
	4940		dataOut.flagNoData = False
	4941
	4942		return dataOut
	4943
	4944		class Block360_vRF4(Operation):
		4271	class Block360(Operation):
	4945	4272	'''
	4946	4273	'''
	4947	4274	isConfig = False
			@@ -4983,9 +4310,10 class Block360_vRF4(Operation):
	4983	4310	Add a profile to he __buffer and increase in one the __profiel Index
	4984	4311	'''
	4985	4312	tmp= getattr(data, attr)
	4986		if ~~tmp~~.~~shape~~[0] != 2:
	4987		~~size_tmp~~= tmp.shape[0]
	4988		tmp=tmp.reshape(1,size_tmp)
		4313	#log.warning(tmp.shape)
		4314	#if tmp.shape[0] != 2:
		4315	# size_tmp= tmp.shape[1]
		4316	# tmp=tmp.reshape(1, size_tmp)
	4989	4317
	4990	4318	self.__buffer.append(tmp)
	4991	4319	self.__buffer2.append(data.azimuth)
			@@ -5116,16 +4444,12 class Block360_vRF4(Operation):
	5116	4444
	5117	4445	if self.__dataReady:
	5118	4446	setattr(dataOut, attr_data, data_360 )
	5119		dataOut.data_azi = data_p
		4447	dataOut.data_azi = data_p + 26.2
		4448	dataOut.data_azi[dataOut.data_azi>360] = dataOut.data_azi[dataOut.data_azi>360] - 360
	5120	4449	dataOut.data_ele = data_e
	5121	4450	dataOut.utctime = avgdatatime
	5122	4451	dataOut.flagNoData = False
	5123	4452	dataOut.flagAskMode = True
	5124		print("AZI: ",dataOut.data_azi)
	5125		print("ELE: ",dataOut.data_ele)
	5126		#print("******************attr_data******************",attr_data)
	5127		#print(data_360.shape)
	5128		#print(dataOut.heightList)
	5129	4453
	5130	4454	return dataOut
	5131	4455

schainpy/model/proc/jroproc_voltage.py +7 -2

                      pair0       = pair0.real
                      lag_0       = numpy.sum(pair0,1)
                      #-----------------Calculo de Cscp------------------------------ New
-                     cspc_pair01 = self.__buffer[0]*self.__buffer[1]
+                     if len(self.__buffer)>1:
+                         cspc_pair01 = self.__buffer[0]*self.__buffer[1]
                      #------------------  Data Decodificada------------------------
                      pwcode =  1
                      if dataOut.flagDecodeData == True:
                      #-------------------- Power --------------------------------------------------
                      data_power       = lag_0/(self.n*self.nCohInt*pwcode)
                      #--------------------CCF------------------------------------------------------
-                     data_ccf         =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
+                     if len(self.__buffer)>1:
+                         data_ccf         =numpy.sum(cspc_pair01,axis=0)/(self.n*self.nCohInt)
+                     else:
+                         data_ccf = 0
                      #------------------  Senal  --------------------------------------------------
                      data_intensity   = pair0 - noise_buffer
                      data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)

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