diff --git a/schainpy/model/graphics/jroplot_base.py b/schainpy/model/graphics/jroplot_base.py index a6a0be0..638c789 100644 --- a/schainpy/model/graphics/jroplot_base.py +++ b/schainpy/model/graphics/jroplot_base.py @@ -531,13 +531,13 @@ class Plot(Operation): 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: diff --git a/schainpy/model/graphics/jroplot_parameters.py b/schainpy/model/graphics/jroplot_parameters.py index 275ec79..1c3a9e0 100644 --- a/schainpy/model/graphics/jroplot_parameters.py +++ b/schainpy/model/graphics/jroplot_parameters.py @@ -369,1433 +369,6 @@ class PolarMapPlot(Plot): self.titles = ['{} {}'.format( self.data.parameters[x], title) for x in self.channels] -class WeatherPlot(Plot): - CODE = 'weather' - plot_name = 'weather' - plot_type = 'ppistyle' - buffering = False - - def setup(self): - self.ncols = 1 - self.nrows = 1 - self.width =8 - self.height =8 - self.nplots= 1 - self.ylabel= 'Range [Km]' - self.titles= ['Weather'] - self.colorbar=False - self.ini =0 - self.len_azi =0 - self.buffer_ini = None - self.buffer_azi = None - self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08}) - self.flag =0 - self.indicador= 0 - self.last_data_azi = None - self.val_mean = None - - def update(self, dataOut): - - data = {} - meta = {} - if hasattr(dataOut, 'dataPP_POWER'): - factor = 1 - if hasattr(dataOut, 'nFFTPoints'): - factor = dataOut.normFactor - #print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape) - data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor)) - data['azi'] = dataOut.data_azi - data['ele'] = dataOut.data_ele - return data, meta - - def get2List(self,angulos): - list1=[] - list2=[] - for i in reversed(range(len(angulos))): - diff_ = angulos[i]-angulos[i-1] - if diff_ >1.5: - list1.append(i-1) - list2.append(diff_) - return list(reversed(list1)),list(reversed(list2)) - - def fixData360(self,list_,ang_): - if list_[0]==-1: - vec = numpy.where(ang_=360) - angulos[vec]=angulos[vec]-360 - return angulos - - def search_pos(self,pos,list_): - for i in range(len(list_)): - if pos == list_[i]: - return True,i - i=None - return False,i - - def fixDataComp(self,ang_,list1_,list2_): - size = len(ang_) - size2 = 0 - for i in range(len(list2_)): - size2=size2+round(list2_[i])-1 - new_size= size+size2 - ang_new = numpy.zeros(new_size) - ang_new2 = numpy.zeros(new_size) - - tmp = 0 - c = 0 - for i in range(len(ang_)): - ang_new[tmp +c] = ang_[i] - ang_new2[tmp+c] = ang_[i] - condition , value = self.search_pos(i,list1_) - if condition: - pos = tmp + c + 1 - for k in range(round(list2_[value])-1): - ang_new[pos+k] = ang_new[pos+k-1]+1 - ang_new2[pos+k] = numpy.nan - tmp = pos +k - c = 0 - c=c+1 - return ang_new,ang_new2 - - def globalCheckPED(self,angulos): - l1,l2 = self.get2List(angulos) - if len(l1)>0: - angulos2 = self.fixData360(list_=l1,ang_=angulos) - l1,l2 = self.get2List(angulos2) - - ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2) - ang1_ = self.fixData360HL(ang1_) - ang2_ = self.fixData360HL(ang2_) - else: - ang1_= angulos - ang2_= angulos - return ang1_,ang2_ - - def analizeDATA(self,data_azi): - list1 = [] - list2 = [] - dat = data_azi - for i in reversed(range(1,len(dat))): - if dat[i]>dat[i-1]: - diff = int(dat[i])-int(dat[i-1]) - else: - diff = 360+int(dat[i])-int(dat[i-1]) - if diff > 1: - list1.append(i-1) - list2.append(diff-1) - return list1,list2 - - def fixDATANEW(self,data_azi,data_weather): - list1,list2 = self.analizeDATA(data_azi) - if len(list1)== 0: - return data_azi,data_weather - else: - resize = 0 - for i in range(len(list2)): - resize= resize + list2[i] - new_data_azi = numpy.resize(data_azi,resize) - new_data_weather= numpy.resize(date_weather,resize) - - for i in range(len(list2)): - j=0 - position=list1[i]+1 - for j in range(list2[i]): - new_data_azi[position+j]=new_data_azi[position+j-1]+1 - return new_data_azi - - def fixDATA(self,data_azi): - data=data_azi - for i in range(len(data)): - if numpy.isnan(data[i]): - data[i]=data[i-1]+1 - return data - - def replaceNAN(self,data_weather,data_azi,val): - data= data_azi - data_T= data_weather - if data.shape[0]> data_T.shape[0]: - data_N = numpy.ones( [data.shape[0],data_T.shape[1]]) - c = 0 - for i in range(len(data)): - if numpy.isnan(data[i]): - data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan - else: - data_N[i,:]=data_T[c,:] - c=c+1 - return data_N - else: - for i in range(len(data)): - if numpy.isnan(data[i]): - data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan - return data_T - - def const_ploteo(self,data_weather,data_azi,step,res): - if self.ini==0: - #------- - n = (360/res)-len(data_azi) - #--------------------- new ------------------------- - data_azi_new ,data_azi_old= self.globalCheckPED(data_azi) - #------------------------ - start = data_azi_new[-1] + res - end = data_azi_new[0] - res - #------ new - self.last_data_azi = end - if start>end: - end = end + 360 - azi_vacia = numpy.linspace(start,end,int(n)) - azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia) - data_azi = numpy.hstack((data_azi_new,azi_vacia)) - # RADAR - val_mean = numpy.mean(data_weather[:,-1]) - self.val_mean = val_mean - data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean - data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean) - data_weather = numpy.vstack((data_weather,data_weather_cmp)) - else: - # azimuth - flag=0 - start_azi = self.res_azi[0] - #-----------new------------ - data_azi ,data_azi_old= self.globalCheckPED(data_azi) - data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean) - #-------------------------- - start = data_azi[0] - end = data_azi[-1] - self.last_data_azi= end - if start< start_azi: - start = start +360 - if end =0)[0] - r = numpy.arange(len(r_mask))*delta_height - self.y = 2*r - # RADAR - #data_weather = data['weather'] - # PEDESTAL - #data_azi = data['azi'] - res = 1 - # STEP - step = (360/(res*data['weather'].shape[0])) - - self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res) - self.res_ele = numpy.mean(data['ele']) - ################# PLOTEO ################### - for i,ax in enumerate(self.axes): - self.zmin = self.zmin if self.zmin else 20 - self.zmax = self.zmax if self.zmax else 80 - if ax.firsttime: - plt.clf() - cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax) - else: - plt.clf() - cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax) - caax = cgax.parasites[0] - paax = cgax.parasites[1] - cbar = plt.gcf().colorbar(pm, pad=0.075) - caax.set_xlabel('x_range [km]') - caax.set_ylabel('y_range [km]') - plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+" Step "+str(self.ini)+ " EL: "+str(round(self.res_ele, 1)), transform=caax.transAxes, va='bottom',ha='right') - - self.ini= self.ini+1 - - -class WeatherRHIPlot(Plot): - CODE = 'weather' - plot_name = 'weather' - plot_type = 'rhistyle' - buffering = False - 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 =12 - 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 - #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]: - 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: - 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) - 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) - #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 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] - ##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] - cg={'angular_spacing': 20.} - if self.ini==0: - self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan - 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): - 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) - self.res_azi = numpy.mean(data['azi']) - if i==0: - print("*****************************************************************************to plot**************************",self.res_weather[i].shape) - self.zmin = self.zmin if self.zmin else 20 - self.zmax = self.zmax if self.zmax else 80 - if ax.firsttime: - #plt.clf() - 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) - #fig=self.figures[0] - else: - #plt.clf() - if i==0: - print(self.res_weather[i]) - print(self.res_ele) - 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) - 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 - -class Weather_vRF_Plot(Plot): - CODE = 'PPI' - plot_name = 'PPI' - #plot_type = 'ppistyle' - buffering = False - - def setup(self): - - self.ncols = 1 - self.nrows = 1 - self.width =8 - self.height =8 - self.nplots= 1 - self.ylabel= 'Range [Km]' - self.xlabel= 'Range [Km]' - self.titles= ['PPI'] - self.polar = True - if self.channels is not None: - self.nplots = len(self.channels) - self.nrows = len(self.channels) - else: - self.nplots = self.data.shape(self.CODE)[0] - self.nrows = self.nplots - self.channels = list(range(self.nplots)) - - if self.CODE == 'POWER': - self.cb_label = r'Power (dB)' - elif self.CODE == 'DOPPLER': - self.cb_label = r'Velocity (m/s)' - self.colorbar=True - self.width = 9 - 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.15, '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 - - if 'pow' in self.attr_data[0].lower(): - data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor)) - else: - data['data'] = getattr(dataOut, self.attr_data[0])/(factor) - - data['azi'] = dataOut.data_azi - data['ele'] = dataOut.data_ele - - return data, meta - - def plot(self): - 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 - r = numpy.arange(len(r_mask))*delta_height - self.y = 2*r - - try: - z = data['data'][self.channels[0]][:,r_mask] - - except: - z = data['data'][0][:,r_mask] - - self.titles = [] - - self.ymax = self.ymax if self.ymax else numpy.nanmax(r) - self.ymin = self.ymin if self.ymin else numpy.nanmin(r) - self.zmax = self.zmax if self.zmax else numpy.nanmax(z) - self.zmin = self.zmin if self.zmin else numpy.nanmin(z) - self.ang_min = self.ang_min if self.ang_min else 0 - self.ang_max = self.ang_max if self.ang_max else 360 - - r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) ) - - for i,ax in enumerate(self.axes): - - if ax.firsttime: - ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max)) - ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax) - ax.set_theta_direction(-1) - - else: - ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max)) - ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax) - ax.set_theta_direction(-1) - - ax.grid(True) - - if len(self.channels) !=1: - 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)] - else: - self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])] - -class WeatherRHI_vRF2_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]: - 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: - 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 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] - ##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] - try: - if self.data[-2]['ele'].max()=0)[0] - self.r_mask =r_mask - r = numpy.arange(len(r_mask))*delta_height - self.y = 2*r - - try: - z = data['data'][self.channels[0]][:,r_mask] - except: - z = data['data'][0][:,r_mask] - - self.titles = [] - - self.ymax = self.ymax if self.ymax else numpy.nanmax(r) - self.ymin = self.ymin if self.ymin else numpy.nanmin(r) - self.zmax = self.zmax if self.zmax else numpy.nanmax(z) - self.zmin = self.zmin if self.zmin else numpy.nanmin(z) - self.ang_min = self.ang_min if self.ang_min else 0 - self.ang_max = self.ang_max if self.ang_max else 90 - - r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) ) - - for i,ax in enumerate(self.axes): - - if ax.firsttime: - ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max)) - ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax) - - else: - ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max)) - ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax) - ax.grid(True) - if len(self.channels) !=1: - self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)] - else: - self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])] - class WeatherParamsPlot(Plot): #CODE = 'RHI' #plot_name = 'RHI' @@ -1879,7 +452,7 @@ class WeatherParamsPlot(Plot): self.ymin = self.ymin if self.ymin else numpy.nanmin(r) self.zmax = self.zmax if self.zmax else numpy.nanmax(z) self.zmin = self.zmin if self.zmin else numpy.nanmin(z) - print("mode inside plot",self.data['mode_op'],data['mode_op']) + if data['mode_op'] == 'RHI': try: if self.data['mode_op'][-2] == 'PPI': @@ -1924,13 +497,13 @@ class WeatherParamsPlot(Plot): len_aux = int(data['azi'].shape[0]/4) mean = numpy.mean(data['azi'][len_aux:-len_aux]) if len(self.channels) !=1: - self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)] + self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)] else: - self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])] + self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])] elif data['mode_op'] == 'PPI': len_aux = int(data['ele'].shape[0]/4) mean = numpy.mean(data['ele'][len_aux:-len_aux]) if len(self.channels) !=1: - self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)] + self.titles = ['PPI {} at EL: {} CH {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)] else: - self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])] + self.titles = ['PPI {} at EL: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])] diff --git a/schainpy/model/proc/jroproc_parameters.py b/schainpy/model/proc/jroproc_parameters.py index 270dd8e..4be6fd9 100644 --- a/schainpy/model/proc/jroproc_parameters.py +++ b/schainpy/model/proc/jroproc_parameters.py @@ -4267,681 +4267,8 @@ class PedestalInformation(Operation): return dataOut -class Block360(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 - ##print("ELVALOR DE n es:", n) - if n == None: - raise ValueError("n should be specified.") - - if mode == None: - raise ValueError("mode should be specified.") - - if n != None: - if n<1: - print("n should be greater than 2") - raise ValueError("n should be greater than 2") - - self.n = n - self.mode = mode - #print("self.mode",self.mode) - #print("nHeights") - self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights)) - self.__buffer2 = numpy.zeros(n) - self.__buffer3 = numpy.zeros(n) - - - - - 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[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO - if self.mode==1: - self.__buffer[:,self.__profIndex,:]= 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[self.__profIndex] = data.azimuth - self.__buffer3[self.__profIndex] = data.elevation - #print("q pasa") - #####self.index+=1 - #print("index",self.index,data.azimuth[:10]) - self.__profIndex += 1 - return #················· Remove DC··································· - - def pushData(self,data): - ''' - Return the PULSEPAIR and the profiles used in the operation - Affected : self.__profileIndex - ''' - #print("pushData") - - data_360 = self.__buffer - data_p = self.__buffer2 - data_e = self.__buffer3 - n = self.__profIndex - - self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis)) - self.__buffer2 = numpy.zeros(self.n) - self.__buffer3 = numpy.zeros(self.n) - 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) - self.putData(data=dataOut,mode = self.mode) - ##### print("profIndex",self.__profIndex) - 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 run(self, dataOut,n = None,mode=None,**kwargs): - #print("BLOCK 360 HERE WE GO MOMENTOS") - print("Block 360") - #exit(1) - if not self.isConfig: - self.setup(dataOut = dataOut, n = n ,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) - 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 - -class Block360_vRF(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 - ##print("ELVALOR DE n es:", n) - if n == None: - raise ValueError("n should be specified.") - - if mode == None: - raise ValueError("mode should be specified.") - - if n != None: - if n<1: - print("n should be greater than 2") - raise ValueError("n should be greater than 2") - - self.n = n - self.mode = mode - #print("self.mode",self.mode) - #print("nHeights") - self.__buffer = numpy.zeros(( dataOut.nChannels,n, dataOut.nHeights)) - self.__buffer2 = numpy.zeros(n) - self.__buffer3 = numpy.zeros(n) - - - - - 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[:,self.__profIndex,:]= data.dataPP_POWER# PRIMER MOMENTO - if self.mode==1: - self.__buffer[:,self.__profIndex,:]= 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[self.__profIndex] = data.azimuth - self.__buffer3[self.__profIndex] = data.elevation - #print("q pasa") - #####self.index+=1 - #print("index",self.index,data.azimuth[:10]) - self.__profIndex += 1 - return #················· Remove DC··································· - - def pushData(self,data): - ''' - Return the PULSEPAIR and the profiles used in the operation - Affected : self.__profileIndex - ''' - #print("pushData") - - data_360 = self.__buffer - data_p = self.__buffer2 - data_e = self.__buffer3 - n = self.__profIndex - - self.__buffer = numpy.zeros((self.__nch, self.n,self.__nHeis)) - self.__buffer2 = numpy.zeros(self.n) - self.__buffer3 = numpy.zeros(self.n) - 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) - self.putData(data=dataOut,mode = self.mode) - ##### print("profIndex",self.__profIndex) - 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): - start = data_ele[0] - end = data_ele[-1] - diff_angle = (end-start) - len_ang=len(data_ele) - print("start",start) - print("end",end) - print("number",diff_angle) - - print("len_ang",len_ang) - - aux = (data_ele<0).any(axis=0) - - #exit(1) - if diff_angle<0 and aux!=1: #Bajada - return 1 - elif diff_angle<0 and aux==1: #Bajada con angulos negativos - return 0 - elif diff_angle == 0: # This case happens when the angle reaches the max_angle if n = 2 - self.flagEraseFirstData = 1 - print("ToDO this case") - exit(1) - elif 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: - if n == 1: - print("*******************Min Value is 2. Setting n = 2*******************") - n = 2 - #exit(1) - print(n) - self.setup(dataOut = dataOut, n = n ,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) - 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.case_flag = self.checkcase(dataOut.data_ele) - if dataOut.case_flag: #Si está de bajada empieza a plotear - print("INSIDE CASE FLAG BAJADA") - dataOut.flagNoData = False - else: - print("CASE SUBIDA") - dataOut.flagNoData = True - - #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 = None - - 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 = [] - self.__buffer4 = [] - - def putData(self,data,mode): - ''' - Add a profile to he __buffer and increase in one the __profiel Index - ''' - - if self.mode==0: - self.__buffer.append(data.dataPP_POWER)# PRIMER MOMENTO - if self.mode==1: - self.__buffer.append(data.data_pow) - - self.__buffer4.append(data.dataPP_DOP) - - self.__buffer2.append(data.azimuth) - self.__buffer3.append(data.elevation) - self.__profIndex += 1 - - return numpy.array(self.__buffer3) #················· Remove DC··································· - - def pushData(self,data): - ''' - Return the PULSEPAIR and the profiles used in the operation - Affected : self.__profileIndex - ''' - - data_360_Power = numpy.array(self.__buffer).transpose(1,0,2) - data_360_Velocity = numpy.array(self.__buffer4).transpose(1,0,2) - data_p = numpy.array(self.__buffer2) - data_e = numpy.array(self.__buffer3) - n = self.__profIndex - - self.__buffer = [] - self.__buffer4 = [] - self.__buffer2 = [] - self.__buffer3 = [] - self.__profIndex = 0 - return data_360_Power,data_360_Velocity,n,data_p,data_e - - - def byProfiles(self,dataOut): - - self.__dataReady = False - data_360_Power = [] - data_360_Velocity = [] - data_p = None - data_e = None - - elevations = self.putData(data=dataOut,mode = self.mode) - - if self.__profIndex > 1: - case_flag = self.checkcase(elevations) - - if case_flag == 0: #Subida - - if len(self.__buffer) == 2: #Cuando está de subida - #Se borra el dato anterior para liberar buffer y comparar el dato actual con el siguiente - self.__buffer.pop(0) #Erase first data - self.__buffer2.pop(0) - self.__buffer3.pop(0) - self.__buffer4.pop(0) - self.__profIndex -= 1 - else: #Cuando ha estado de bajada y ha vuelto a subir - #Se borra el último dato - self.__buffer.pop() #Erase last data - self.__buffer2.pop() - self.__buffer3.pop() - self.__buffer4.pop() - data_360_Power,data_360_Velocity,n,data_p,data_e = self.pushData(data=dataOut) - - self.__dataReady = True - - return data_360_Power,data_360_Velocity,data_p,data_e - - - def blockOp(self, dataOut, datatime= None): - if self.__initime == None: - self.__initime = datatime - data_360_Power,data_360_Velocity,data_p,data_e = self.byProfiles(dataOut) - self.__lastdatatime = datatime - - avgdatatime = self.__initime - if self.n==1: - avgdatatime = datatime - deltatime = datatime - self.__lastdatatime - self.__initime = datatime - return data_360_Power,data_360_Velocity,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,mode='Power',**kwargs): - #print("BLOCK 360 HERE WE GO MOMENTOS") - #print("Block 360") - dataOut.mode = mode - - if not self.isConfig: - self.setup(dataOut = dataOut ,mode= mode ,**kwargs) - self.isConfig = True - - - data_360_Power, data_360_Velocity, avgdatatime,data_p,data_e = self.blockOp(dataOut, dataOut.utctime) - - - dataOut.flagNoData = True - - - if self.__dataReady: - dataOut.data_360_Power = data_360_Power # S - dataOut.data_360_Velocity = data_360_Velocity - dataOut.data_azi = data_p - dataOut.data_ele = data_e - dataOut.utctime = avgdatatime - dataOut.flagNoData = False - - return dataOut - -class Block360_vRF3(Operation): - ''' - ''' - isConfig = False - __profIndex = 0 - __initime = None - __lastdatatime = None - __buffer = None - __dataReady = False - n = None - __nch = 0 - __nHeis = 0 - index = 0 - mode = None - - def __init__(self,**kwargs): - Operation.__init__(self,**kwargs) - - def setup(self, dataOut, attr): - ''' - n= Numero de PRF's de entrada - ''' - self.__initime = None - self.__lastdatatime = 0 - self.__dataReady = False - self.__buffer = 0 - self.__buffer_1D = 0 - self.index = 0 - self.__nch = dataOut.nChannels - self.__nHeis = dataOut.nHeights - - self.attr = attr - #print("self.mode",self.mode) - #print("nHeights") - self.__buffer = [] - self.__buffer2 = [] - self.__buffer3 = [] - - def putData(self, data, attr): - ''' - Add a profile to he __buffer and increase in one the __profiel Index - ''' - - self.__buffer.append(getattr(data, attr)) - self.__buffer2.append(data.azimuth) - self.__buffer3.append(data.elevation) - self.__profIndex += 1 - - return numpy.array(self.__buffer3) - - def pushData(self, data): - ''' - Return the PULSEPAIR and the profiles used in the operation - Affected : self.__profileIndex - ''' - - 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 - return data_360, n, data_p, data_e - - - def byProfiles(self,dataOut): - - self.__dataReady = False - data_360 = [] - data_p = None - data_e = None - - elevations = self.putData(data=dataOut, attr = self.attr) - - if self.__profIndex > 1: - case_flag = self.checkcase(elevations) - - if case_flag == 0: #Subida - - if len(self.__buffer) == 2: #Cuando está de subida - #Se borra el dato anterior para liberar buffer y comparar el dato actual con el siguiente - 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 - #Se borra el último dato - 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 - - 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 - - avgdatatime = self.__initime - if self.n==1: - avgdatatime = datatime - deltatime = datatime - self.__lastdatatime - self.__initime = datatime - return data_360, avgdatatime, data_p, data_e - - def checkcase(self, 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, attr_data='dataPP_POWER',**kwargs): - - dataOut.attr_data = attr_data - - if not self.isConfig: - self.setup(dataOut = dataOut, attr = attr_data ,**kwargs) - self.isConfig = True - - data_360, avgdatatime, data_p, data_e = self.blockOp(dataOut, dataOut.utctime) - - dataOut.flagNoData = True - - if self.__dataReady: - setattr(dataOut, attr_data, data_360 ) - dataOut.data_azi = data_p - dataOut.data_ele = data_e - dataOut.utctime = avgdatatime - dataOut.flagNoData = False - - return dataOut - -class Block360_vRF4(Operation): +class Block360(Operation): ''' ''' isConfig = False @@ -4983,9 +4310,10 @@ class Block360_vRF4(Operation): Add a profile to he __buffer and increase in one the __profiel Index ''' tmp= getattr(data, attr) - if tmp.shape[0] != 2: - size_tmp= tmp.shape[0] - tmp=tmp.reshape(1,size_tmp) + #log.warning(tmp.shape) + #if tmp.shape[0] != 2: + # size_tmp= tmp.shape[1] + # tmp=tmp.reshape(1, size_tmp) self.__buffer.append(tmp) self.__buffer2.append(data.azimuth) @@ -5116,16 +4444,12 @@ class Block360_vRF4(Operation): if self.__dataReady: setattr(dataOut, attr_data, data_360 ) - dataOut.data_azi = data_p + dataOut.data_azi = data_p + 26.2 + dataOut.data_azi[dataOut.data_azi>360] = dataOut.data_azi[dataOut.data_azi>360] - 360 dataOut.data_ele = data_e dataOut.utctime = avgdatatime dataOut.flagNoData = False dataOut.flagAskMode = True - print("AZI: ",dataOut.data_azi) - print("ELE: ",dataOut.data_ele) - #print("********************attr_data********************",attr_data) - #print(data_360.shape) - #print(dataOut.heightList) return dataOut diff --git a/schainpy/model/proc/jroproc_voltage.py b/schainpy/model/proc/jroproc_voltage.py index 3acbd94..b3f0d10 100644 --- a/schainpy/model/proc/jroproc_voltage.py +++ b/schainpy/model/proc/jroproc_voltage.py @@ -1617,7 +1617,8 @@ class PulsePair_vRF(Operation): 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: @@ -1637,7 +1638,11 @@ class PulsePair_vRF(Operation): #-------------------- 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)