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	self.titles = ['{} {}'.format(	369	self.titles = ['{} {}'.format(
	370	self.data.parameters[x], title) for x in self.channels]	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	class WeatherParamsPlot(Plot):	372	class WeatherParamsPlot(Plot):
	1800	#CODE = 'RHI'	373	#CODE = 'RHI'
	1801	#plot_name = 'RHI'	374	#plot_name = 'RHI'
	@@ -1879,7 +452,7 class WeatherParamsPlot(Plot):
	1879	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)	452	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
	1880	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)	453	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	1881	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)	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	if data['mode_op'] == 'RHI':	456	if data['mode_op'] == 'RHI':
	1884	try:	457	try:
	1885	if self.data['mode_op'][-2] == 'PPI':	458	if self.data['mode_op'][-2] == 'PPI':
	@@ -1924,13 +497,13 class WeatherParamsPlot(Plot):
	1924	len_aux = int(data['azi'].shape[0]/4)	497	len_aux = int(data['azi'].shape[0]/4)
	1925	mean = numpy.mean(data['azi'][len_aux:-len_aux])	498	mean = numpy.mean(data['azi'][len_aux:-len_aux])
	1926	if len(self.channels) !=1:	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	else:	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	elif data['mode_op'] == 'PPI':	503	elif data['mode_op'] == 'PPI':
	1931	len_aux = int(data['ele'].shape[0]/4)	504	len_aux = int(data['ele'].shape[0]/4)
	1932	mean = numpy.mean(data['ele'][len_aux:-len_aux])	505	mean = numpy.mean(data['ele'][len_aux:-len_aux])
	1933	if len(self.channels) !=1:	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	else:	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	return dataOut	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):	4271	class Block360(Operation):
	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):
	4945	'''	4272	'''
	4946	'''	4273	'''
	4947	isConfig = False	4274	isConfig = False
	@@ -4983,9 +4310,10 class Block360_vRF4(Operation):
	4983	Add a profile to he __buffer and increase in one the __profiel Index	4310	Add a profile to he __buffer and increase in one the __profiel Index
	4984	'''	4311	'''
	4985	tmp= getattr(data, attr)	4312	tmp= getattr(data, attr)
	4986	if ~~tmp~~.~~shape~~[0] != 2:	4313	#log.warning(tmp.shape)
	4987	~~size_tmp~~= tmp.shape[0]	4314	#if tmp.shape[0] != 2:
	4988	tmp=tmp.reshape(1,size_tmp)	4315	# size_tmp= tmp.shape[1]
			4316	# tmp=tmp.reshape(1, size_tmp)
	4989		4317
	4990	self.__buffer.append(tmp)	4318	self.__buffer.append(tmp)
	4991	self.__buffer2.append(data.azimuth)	4319	self.__buffer2.append(data.azimuth)
	@@ -5116,16 +4444,12 class Block360_vRF4(Operation):
	5116		4444
	5117	if self.__dataReady:	4445	if self.__dataReady:
	5118	setattr(dataOut, attr_data, data_360 )	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	dataOut.data_ele = data_e	4449	dataOut.data_ele = data_e
	5121	dataOut.utctime = avgdatatime	4450	dataOut.utctime = avgdatatime
	5122	dataOut.flagNoData = False	4451	dataOut.flagNoData = False
	5123	dataOut.flagAskMode = True	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	return dataOut	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