diff --git a/schainpy/model/graphics/jroplot_parameters.py b/schainpy/model/graphics/jroplot_parameters.py index 0502c7e..0dc1684 100644 --- a/schainpy/model/graphics/jroplot_parameters.py +++ b/schainpy/model/graphics/jroplot_parameters.py @@ -1,6 +1,7 @@ import os import datetime import numpy +from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter from schainpy.model.graphics.jroplot_base import Plot, plt from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot @@ -1863,3 +1864,515 @@ class WeatherRHI_vRF_Plot(Plot): plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right') print("***************************self.ini****************************",self.ini) self.ini= self.ini+1 + +class WeatherRHI_vRF3_Plot(Plot): + CODE = 'weather' + plot_name = 'weather' + plot_type = 'rhistyle' + buffering = False + data_ele_tmp = None + + def setup(self): + print("********************") + print("********************") + print("********************") + print("SETUP WEATHER PLOT") + self.ncols = 1 + self.nrows = 1 + self.nplots= 1 + self.ylabel= 'Range [Km]' + self.titles= ['Weather'] + if self.channels is not None: + self.nplots = len(self.channels) + self.nrows = len(self.channels) + else: + self.nplots = self.data.shape(self.CODE)[0] + self.nrows = self.nplots + self.channels = list(range(self.nplots)) + print("channels",self.channels) + print("que saldra", self.data.shape(self.CODE)[0]) + self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)] + print("self.titles",self.titles) + self.colorbar=False + self.width =8 + self.height =8 + self.ini =0 + self.len_azi =0 + self.buffer_ini = None + self.buffer_ele = None + self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08}) + self.flag =0 + self.indicador= 0 + self.last_data_ele = None + self.val_mean = None + + def update(self, dataOut): + + data = {} + meta = {} + if hasattr(dataOut, 'dataPP_POWER'): + factor = 1 + if hasattr(dataOut, 'nFFTPoints'): + factor = dataOut.normFactor + print("dataOut",dataOut.data_360.shape) + # + data['weather'] = 10*numpy.log10(dataOut.data_360/(factor)) + # + #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor)) + data['azi'] = dataOut.data_azi + data['ele'] = dataOut.data_ele + #data['case_flag'] = dataOut.case_flag + #print("UPDATE") + #print("data[weather]",data['weather'].shape) + #print("data[azi]",data['azi']) + return data, meta + + def get2List(self,angulos): + list1=[] + list2=[] + for i in reversed(range(len(angulos))): + if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante + diff_ = angulos[i]-angulos[i-1] + if abs(diff_) >1.5: + list1.append(i-1) + list2.append(diff_) + return list(reversed(list1)),list(reversed(list2)) + + def fixData90(self,list_,ang_): + if list_[0]==-1: + vec = numpy.where(ang_=90) + angulos[vec]=angulos[vec]-90 + return angulos + + + def search_pos(self,pos,list_): + for i in range(len(list_)): + if pos == list_[i]: + return True,i + i=None + return False,i + + def fixDataComp(self,ang_,list1_,list2_,tipo_case): + size = len(ang_) + size2 = 0 + for i in range(len(list2_)): + size2=size2+round(abs(list2_[i]))-1 + new_size= size+size2 + ang_new = numpy.zeros(new_size) + ang_new2 = numpy.zeros(new_size) + + tmp = 0 + c = 0 + for i in range(len(ang_)): + ang_new[tmp +c] = ang_[i] + ang_new2[tmp+c] = ang_[i] + condition , value = self.search_pos(i,list1_) + if condition: + pos = tmp + c + 1 + for k in range(round(abs(list2_[value]))-1): + if tipo_case==0 or tipo_case==3:#subida + ang_new[pos+k] = ang_new[pos+k-1]+1 + ang_new2[pos+k] = numpy.nan + elif tipo_case==1 or tipo_case==2:#bajada + ang_new[pos+k] = ang_new[pos+k-1]-1 + ang_new2[pos+k] = numpy.nan + + tmp = pos +k + c = 0 + c=c+1 + return ang_new,ang_new2 + + def globalCheckPED(self,angulos,tipo_case): + l1,l2 = self.get2List(angulos) + ##print("l1",l1) + ##print("l2",l2) + if len(l1)>0: + #angulos2 = self.fixData90(list_=l1,ang_=angulos) + #l1,l2 = self.get2List(angulos2) + ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case) + #ang1_ = self.fixData90HL(ang1_) + #ang2_ = self.fixData90HL(ang2_) + else: + ang1_= angulos + ang2_= angulos + return ang1_,ang2_ + + + def replaceNAN(self,data_weather,data_ele,val): + data= data_ele + data_T= data_weather + + if data.shape[0]> data_T.shape[0]: + print("IF") + data_N = numpy.ones( [data.shape[0],data_T.shape[1]]) + c = 0 + for i in range(len(data)): + if numpy.isnan(data[i]): + data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan + else: + data_N[i,:]=data_T[c,:] + c=c+1 + return data_N + else: + print("else") + for i in range(len(data)): + if numpy.isnan(data[i]): + data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan + return data_T + + def check_case(self,data_ele,ang_max,ang_min): + start = data_ele[0] + end = data_ele[-1] + number = (end-start) + len_ang=len(data_ele) + print("start",start) + print("end",end) + print("number",number) + + print("len_ang",len_ang) + + #exit(1) + + if start=len_ang or (numpy.argmin(data_ele)==0)):#caso subida + return 0 + #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada + # return 1 + elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada + return 1 + elif round(abs(number)+1)data_ele[-1]:# caso BAJADA CAMBIO ANG MAX + return 2 + elif round(abs(number)+1)0: + ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1) + ele1_nan= numpy.ones(n1)*numpy.nan + data_ele = numpy.hstack((ele1,data_ele_new)) + print("ele1_nan",ele1_nan.shape) + print("data_ele_old",data_ele_old.shape) + data_ele_old = numpy.hstack((ele1_nan,data_ele_old)) + if n2>0: + ele2= numpy.linspace(self.end_data_ele+1,end,n2) + ele2_nan= numpy.ones(n2)*numpy.nan + data_ele = numpy.hstack((data_ele,ele2)) + print("ele2_nan",ele2_nan.shape) + print("data_ele_old",data_ele_old.shape) + data_ele_old = numpy.hstack((data_ele_old,ele2_nan)) + + if tipo_case==1 or tipo_case==2: # BAJADA + data_ele_new = data_ele_new[::-1] # reversa + data_ele_old = data_ele_old[::-1]# reversa + data_weather = data_weather[::-1,:]# reversa + vec= numpy.where(data_ele_new0: + ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1) + ele1_nan= numpy.ones(n1)*numpy.nan + data_ele = numpy.hstack((ele1,data_ele_new)) + data_ele_old = numpy.hstack((ele1_nan,data_ele_old)) + if n2>0: + ele2= numpy.linspace(self.end_data_ele+1,end,n2) + ele2_nan= numpy.ones(n2)*numpy.nan + data_ele = numpy.hstack((data_ele,ele2)) + data_ele_old = numpy.hstack((data_ele_old,ele2_nan)) + # RADAR + # NOTA data_ele y data_weather es la variable que retorna + val_mean = numpy.mean(data_weather[:,-1]) + self.val_mean = val_mean + data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) + print("eleold",data_ele_old) + print(self.data_ele_tmp[val_ch]) + print(data_ele_old.shape[0]) + print(self.data_ele_tmp[val_ch].shape[0]) + if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91): + import sys + print("EXIT",self.ini) + + sys.exit(1) + self.data_ele_tmp[val_ch]= data_ele_old + else: + #print("**********************************************") + #print("****************VARIABLE**********************") + #-------------------------CAMBIOS RHI--------------------------------- + #--------------------------------------------------------------------- + ##print("INPUT data_ele",data_ele) + flag=0 + start_ele = self.res_ele[0] + #tipo_case = self.check_case(data_ele,ang_max,ang_min) + tipo_case = case_flag[-1] + #print("TIPO DE DATA",tipo_case) + #-----------new------------ + data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case) + data_weather = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) + + #-------------------------------NEW RHI ITERATIVO------------------------- + + if tipo_case==0 : # SUBIDA + vec = numpy.where(data_ele=ang_max-1: + self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan + 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) + self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old + self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele + self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather + data_ele = self.res_ele + data_weather = self.res_weather[val_ch] + + elif tipo_case==2: #bajada + vec = numpy.where(data_ele0: + ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1) + ele1_nan= numpy.ones(n1)*numpy.nan + data_ele = numpy.hstack((ele1,data_ele_new)) + data_ele_old = numpy.hstack((ele1_nan,data_ele_new)) + if n2>0: + ele2= numpy.linspace(new_f_ele+1,ang_max,n2) + ele2_nan= numpy.ones(n2)*numpy.nan + data_ele = numpy.hstack((data_ele,ele2)) + data_ele_old = numpy.hstack((data_ele_old,ele2_nan)) + + self.data_ele_tmp[val_ch] = data_ele_old + self.res_ele = data_ele + self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) + data_ele = self.res_ele + data_weather = self.res_weather[val_ch] + + elif tipo_case==3:#subida + vec = numpy.where(00: + len_vec= len(data_ele) + vec3 = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int) + #print(vec3) + data_ele= data_ele[vec3] + data_ele_new = data_ele + data_ele_old= data_ele_old[vec3] + data_weather= data_weather[vec3] + + new_i_ele = int(data_ele_new[0]) + new_f_ele = int(data_ele_new[-1]) + n1= new_i_ele- ang_min + n2= ang_max - new_f_ele-1 + if n1>0: + ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1) + ele1_nan= numpy.ones(n1)*numpy.nan + data_ele = numpy.hstack((ele1,data_ele_new)) + data_ele_old = numpy.hstack((ele1_nan,data_ele_new)) + if n2>0: + ele2= numpy.linspace(new_f_ele+1,ang_max,n2) + ele2_nan= numpy.ones(n2)*numpy.nan + data_ele = numpy.hstack((data_ele,ele2)) + data_ele_old = numpy.hstack((data_ele_old,ele2_nan)) + + self.data_ele_tmp[val_ch] = data_ele_old + self.res_ele = data_ele + self.res_weather[val_ch] = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean) + data_ele = self.res_ele + data_weather = self.res_weather[val_ch] + #print("self.data_ele_tmp",self.data_ele_tmp) + return data_weather,data_ele + + def const_ploteo_vRF(self,val_ch,data_weather,data_ele,res,ang_max,ang_min): + + data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,1) + + data_ele = data_ele_old.copy() + + diff_1 = ang_max - data_ele[0] + angles_1_nan = numpy.linspace(ang_max,data_ele[0]+1,int(diff_1)-1)#*numpy.nan + + diff_2 = data_ele[-1]-ang_min + angles_2_nan = numpy.linspace(data_ele[-1]-1,ang_min,int(diff_2)-1)#*numpy.nan + + angles_filled = numpy.concatenate((angles_1_nan,data_ele,angles_2_nan)) + + print(angles_filled) + + data_1_nan = numpy.ones([angles_1_nan.shape[0],len(self.r_mask)])*numpy.nan + data_2_nan = numpy.ones([angles_2_nan.shape[0],len(self.r_mask)])*numpy.nan + + data_filled = numpy.concatenate((data_1_nan,data_weather,data_2_nan),axis=0) + #val_mean = numpy.mean(data_weather[:,-1]) + #self.val_mean = val_mean + print(data_filled) + data_filled = self.replaceNAN(data_weather=data_filled,data_ele=angles_filled,val=numpy.nan) + + print(data_filled) + print(data_filled.shape) + print(angles_filled.shape) + + return data_filled,angles_filled + + def plot(self): + thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S') + data = self.data[-1] + r = self.data.yrange + delta_height = r[1]-r[0] + r_mask = numpy.where(r>=0)[0] + self.r_mask =r_mask + ##print("delta_height",delta_height) + #print("r_mask",r_mask,len(r_mask)) + r = numpy.arange(len(r_mask))*delta_height + self.y = 2*r + res = 1 + ###print("data['weather'].shape[0]",data['weather'].shape[0]) + ang_max = self.ang_max + ang_min = self.ang_min + var_ang =ang_max - ang_min + step = (int(var_ang)/(res*data['weather'].shape[0])) + ###print("step",step) + #-------------------------------------------------------- + ##print('weather',data['weather'].shape) + ##print('ele',data['ele'].shape) + + ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min) + ###self.res_azi = numpy.mean(data['azi']) + ###print("self.res_ele",self.res_ele) + + plt.clf() + subplots = [121, 122] + #if self.ini==0: + #self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan + #print("SHAPE",self.data_ele_tmp.shape) + + for i,ax in enumerate(self.axes): + res_weather, self.res_ele = self.const_ploteo_vRF(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],res=res,ang_max=ang_max,ang_min=ang_min) + self.res_azi = numpy.mean(data['azi']) + + if ax.firsttime: + #plt.clf() + print("Frist Plot") + print(data['weather'][i][:,r_mask].shape) + print(data['ele'].shape) + cgax, pm = wrl.vis.plot_rhi(res_weather,r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80) + #cgax, pm = wrl.vis.plot_rhi(data['weather'][i][:,r_mask],r=r,th=data['ele'],ax=subplots[i], proj='cg',vmin=20, vmax=80) + gh = cgax.get_grid_helper() + locs = numpy.linspace(ang_min,ang_max,var_ang+1) + gh.grid_finder.grid_locator1 = FixedLocator(locs) + gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs])) + + + #fig=self.figures[0] + else: + #plt.clf() + print("ELSE PLOT") + cgax, pm = wrl.vis.plot_rhi(res_weather,r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80) + #cgax, pm = wrl.vis.plot_rhi(data['weather'][i][:,r_mask],r=r,th=data['ele'],ax=subplots[i], proj='cg',vmin=20, vmax=80) + gh = cgax.get_grid_helper() + locs = numpy.linspace(ang_min,ang_max,var_ang+1) + gh.grid_finder.grid_locator1 = FixedLocator(locs) + gh.grid_finder.tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs])) + + caax = cgax.parasites[0] + paax = cgax.parasites[1] + cbar = plt.gcf().colorbar(pm, pad=0.075) + caax.set_xlabel('x_range [km]') + caax.set_ylabel('y_range [km]') + plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+" Step "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right') + print("***************************self.ini****************************",self.ini) + self.ini= self.ini+1 diff --git a/schainpy/model/proc/jroproc_parameters.py b/schainpy/model/proc/jroproc_parameters.py index f44f1aa..9a6e58a 100755 --- a/schainpy/model/proc/jroproc_parameters.py +++ b/schainpy/model/proc/jroproc_parameters.py @@ -4620,3 +4620,214 @@ class Block360_vRF(Operation): #dataOut.flagNoData = False return dataOut + +class Block360_vRF2(Operation): + ''' + ''' + isConfig = False + __profIndex = 0 + __initime = None + __lastdatatime = None + __buffer = None + __dataReady = False + n = None + __nch = 0 + __nHeis = 0 + index = 0 + mode = 0 + + def __init__(self,**kwargs): + Operation.__init__(self,**kwargs) + + def setup(self, dataOut, n = None, mode = None): + ''' + n= Numero de PRF's de entrada + ''' + self.__initime = None + self.__lastdatatime = 0 + self.__dataReady = False + self.__buffer = 0 + self.__buffer_1D = 0 + #self.__profIndex = 0 + self.index = 0 + self.__nch = dataOut.nChannels + self.__nHeis = dataOut.nHeights + + self.mode = mode + #print("self.mode",self.mode) + #print("nHeights") + self.__buffer = [] + self.__buffer2 = [] + self.__buffer3 = [] + + def putData(self,data,mode): + ''' + Add a profile to he __buffer and increase in one the __profiel Index + ''' + #print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10]) + #print("line 4049",data.azimuth.shape,data.azimuth) + if self.mode==0: + self.__buffer.append(data.dataPP_POWER)# PRIMER MOMENTO + if self.mode==1: + self.__buffer.append(data.data_pow) + #print("me casi",self.index,data.azimuth[self.index]) + #print(self.__profIndex, self.index , data.azimuth[self.index] ) + #print("magic",data.profileIndex) + #print(data.azimuth[self.index]) + #print("index",self.index) + + #####self.__buffer2[self.__profIndex] = data.azimuth[self.index] + self.__buffer2.append(data.azimuth) + self.__buffer3.append(data.elevation) + self.__profIndex += 1 + #print("q pasa") + return numpy.array(self.__buffer3) #················· Remove DC··································· + + def pushData(self,data): + ''' + Return the PULSEPAIR and the profiles used in the operation + Affected : self.__profileIndex + ''' + #print("pushData") + + data_360 = numpy.array(self.__buffer).transpose(1,0,2) + data_p = numpy.array(self.__buffer2) + data_e = numpy.array(self.__buffer3) + n = self.__profIndex + + self.__buffer = [] + self.__buffer2 = [] + self.__buffer3 = [] + self.__profIndex = 0 + #print("pushData") + return data_360,n,data_p,data_e + + + def byProfiles(self,dataOut): + + self.__dataReady = False + data_360 = None + data_p = None + data_e = None + #print("dataOu",dataOut.dataPP_POW) + + elevations = self.putData(data=dataOut,mode = self.mode) + ##### print("profIndex",self.__profIndex) + + + if self.__profIndex > 1: + case_flag = self.checkcase(elevations) + + if case_flag == 0: #Subida + #Se borra el dato anterior para liberar buffer y comparar el dato actual con el siguiente + if len(self.__buffer) == 2: #Cuando está de subida + self.__buffer.pop(0) #Erase first data + self.__buffer2.pop(0) + self.__buffer3.pop(0) + self.__profIndex -= 1 + else: #Cuando ha estado de bajada y ha vuelto a subir + #print("else",self.__buffer3) + self.__buffer.pop() #Erase last data + self.__buffer2.pop() + self.__buffer3.pop() + data_360,n,data_p,data_e = self.pushData(data=dataOut) + #print(data_360.shape) + #print(data_e.shape) + #exit(1) + self.__dataReady = True + ''' + elif elevations[-1]<0.: + if len(self.__buffer) == 2: + self.__buffer.pop(0) #Erase first data + self.__buffer2.pop(0) + self.__buffer3.pop(0) + self.__profIndex -= 1 + else: + self.__buffer.pop() #Erase last data + self.__buffer2.pop() + self.__buffer3.pop() + data_360,n,data_p,data_e = self.pushData(data=dataOut) + self.__dataReady = True + ''' + + + ''' + if self.__profIndex == self.n: + data_360,n,data_p,data_e = self.pushData(data=dataOut) + self.__dataReady = True + ''' + + return data_360,data_p,data_e + + + def blockOp(self, dataOut, datatime= None): + if self.__initime == None: + self.__initime = datatime + data_360,data_p,data_e = self.byProfiles(dataOut) + self.__lastdatatime = datatime + + if data_360 is None: + return None, None,None,None + + + avgdatatime = self.__initime + if self.n==1: + avgdatatime = datatime + deltatime = datatime - self.__lastdatatime + self.__initime = datatime + #print(data_360.shape,avgdatatime,data_p.shape) + return data_360,avgdatatime,data_p,data_e + + def checkcase(self,data_ele): + print(data_ele) + start = data_ele[-2] + end = data_ele[-1] + diff_angle = (end-start) + len_ang=len(data_ele) + + if diff_angle > 0: #Subida + return 0 + + def run(self, dataOut,n = None,mode=None,**kwargs): + #print("BLOCK 360 HERE WE GO MOMENTOS") + print("Block 360") + + #exit(1) + if not self.isConfig: + + print(n) + self.setup(dataOut = dataOut ,mode= mode ,**kwargs) + ####self.index = 0 + #print("comova",self.isConfig) + self.isConfig = True + ####if self.index==dataOut.azimuth.shape[0]: + #### self.index=0 + + data_360, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime) + + + + + dataOut.flagNoData = True + + if self.__dataReady: + dataOut.data_360 = data_360 # S + #print("DATA 360") + #print(dataOut.data_360) + #print("---------------------------------------------------------------------------------") + print("---------------------------DATAREADY---------------------------------------------") + #print("---------------------------------------------------------------------------------") + #print("data_360",dataOut.data_360.shape) + print(data_e) + #exit(1) + dataOut.data_azi = data_p + dataOut.data_ele = data_e + ###print("azi: ",dataOut.data_azi) + #print("ele: ",dataOut.data_ele) + #print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime) + dataOut.utctime = avgdatatime + + + + dataOut.flagNoData = False + return dataOut