schain Commit - r1461:773419e042d4 · Jicamarca Repository

PPI or RHI mode Detection/GeneralPlot

rflores -

r1461:773419e042d4

parent child

Context file:

r1461:773419e042d4

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

                     self.mode = kwargs.get('mode', None)
                     if self.server:
                         if not self.server.startswith('tcp://'):
                             self.server = 'tcp://{}'.format(self.server)
                     self.save_time = self.data.max_time
                     fig = self.figures[n]
+                    print("save_code",self.save_code)
                     if self.throttle == 0:
                         if self.oneFigure:
                             figname = os.path.join(

schainpy/model/graphics/jroplot_parameters.py +141 -2

@@ -7,7 +7,7 from schainpy.model.graphics.jroplot_base import Plot, plt
7	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot	7	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
8	from schainpy.utils import log	8	from schainpy.utils import log
9	# libreria wradlib	9	# libreria wradlib
10	import wradlib as wrl	10	#import wradlib as wrl
11		11
12	EARTH_RADIUS = 6.3710e3	12	EARTH_RADIUS = 6.3710e3
13		13
@@ -1176,7 +1176,11 class Weather_vRF_Plot(Plot):
1176	r = numpy.arange(len(r_mask))*delta_height	1176	r = numpy.arange(len(r_mask))*delta_height
1177	self.y = 2*r	1177	self.y = 2*r
1178		1178
1179	z = data['data'][self.channels[0]][:,r_mask]	1179	try:
		1180	z = data['data'][self.channels[0]][:,r_mask]
		1181
		1182	except:
		1183	z = data['data'][0][:,r_mask]
1180		1184
1181	self.titles = []	1185	self.titles = []
1182		1186
@@ -1791,3 +1795,138 class WeatherRHI_vRF4_Plot(Plot):
1791	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]	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)]
1792	else:	1796	else:
1793	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]	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):
		1800	#CODE = 'RHI'
		1801	#plot_name = 'RHI'
		1802	#plot_type = 'rhistyle'
		1803	buffering = False
		1804
		1805	def setup(self):
		1806
		1807	self.ncols = 1
		1808	self.nrows = 1
		1809	self.nplots= 1
		1810	self.ylabel= 'Range [Km]'
		1811	self.xlabel= 'Range [Km]'
		1812	self.polar = True
		1813	self.grid = True
		1814	if self.channels is not None:
		1815	self.nplots = len(self.channels)
		1816	self.nrows = len(self.channels)
		1817	else:
		1818	self.nplots = self.data.shape(self.CODE)[0]
		1819	self.nrows = self.nplots
		1820	self.channels = list(range(self.nplots))
		1821
		1822	self.colorbar=True
		1823	self.width =8
		1824	self.height =8
		1825	self.ini =0
		1826	self.len_azi =0
		1827	self.buffer_ini = None
		1828	self.buffer_ele = None
		1829	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
		1830	self.flag =0
		1831	self.indicador= 0
		1832	self.last_data_ele = None
		1833	self.val_mean = None
		1834
		1835	def update(self, dataOut):
		1836
		1837	data = {}
		1838	meta = {}
		1839	if hasattr(dataOut, 'dataPP_POWER'):
		1840	factor = 1
		1841	if hasattr(dataOut, 'nFFTPoints'):
		1842	factor = dataOut.normFactor
		1843
		1844	if 'pow' in self.attr_data[0].lower():
		1845	data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
		1846	else:
		1847	data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
		1848
		1849	if dataOut.mode_op == 'PPI':
		1850	self.CODE = 'PPI'
		1851	self.title = self.CODE
		1852	elif dataOut.mode_op == 'RHI':
		1853	self.CODE = 'RHI'
		1854	self.title = self.CODE
		1855
		1856	data['azi'] = dataOut.data_azi
		1857	data['ele'] = dataOut.data_ele
		1858	data['mode_op'] = dataOut.mode_op
		1859
		1860	return data, meta
		1861
		1862	def plot(self):
		1863	data = self.data[-1]
		1864	r = self.data.yrange
		1865	delta_height = r[1]-r[0]
		1866	r_mask = numpy.where(r>=0)[0]
		1867	self.r_mask =r_mask
		1868	r = numpy.arange(len(r_mask))*delta_height
		1869	self.y = 2*r
		1870
		1871	try:
		1872	z = data['data'][self.channels[0]][:,r_mask]
		1873	except:
		1874	z = data['data'][0][:,r_mask]
		1875
		1876	self.titles = []
		1877
		1878	self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
		1879	self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
		1880	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
		1881	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
		1882	print("mode inside plot",self.data['mode_op'],data['mode_op'])
		1883	if data['mode_op'] == 'RHI':
		1884	try:
		1885	if self.data['mode_op'][-2] == 'PPI':
		1886	self.ang_min = None
		1887	self.ang_max = None
		1888	except:
		1889	pass
		1890	self.ang_min = self.ang_min if self.ang_min else 0
		1891	self.ang_max = self.ang_max if self.ang_max else 90
		1892	r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
		1893	elif data['mode_op'] == 'PPI':
		1894	try:
		1895	if self.data['mode_op'][-2] == 'RHI':
		1896	self.ang_min = None
		1897	self.ang_max = None
		1898	except:
		1899	pass
		1900	self.ang_min = self.ang_min if self.ang_min else 0
		1901	self.ang_max = self.ang_max if self.ang_max else 360
		1902	r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
		1903
		1904	self.clear_figures()
		1905
		1906	for i,ax in enumerate(self.axes):
		1907
		1908	if ax.firsttime:
		1909	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
		1910	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
		1911	if data['mode_op'] == 'PPI':
		1912	ax.set_theta_direction(-1)
		1913	else:
		1914	ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
		1915	ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
		1916	if data['mode_op'] == 'PPI':
		1917	ax.set_theta_direction(-1)
		1918	ax.grid(True)
		1919	if data['mode_op'] == 'RHI':
		1920	len_aux = int(data['azi'].shape[0]/4)
		1921	mean = numpy.mean(data['azi'][len_aux:-len_aux])
		1922	if len(self.channels) !=1:
		1923	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
		1924	else:
		1925	self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
		1926	elif data['mode_op'] == 'PPI':
		1927	len_aux = int(data['ele'].shape[0]/4)
		1928	mean = numpy.mean(data['ele'][len_aux:-len_aux])
		1929	if len(self.channels) !=1:
		1930	self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
		1931	else:
		1932	self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]

schainpy/model/io/jroIO_digitalRF.py 0 -4

                     self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
-                    #self.__samples_to_read  = int(1000000)  # FIJO: AHORA 40
                     self.__nChannels        = len(self.__channelList)
                     #print("------------------------------------------")
                     #print("self.__samples_to_read",self.__samples_to_read)
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
                                 t0     = time()
-                                #print("Unitindex",self.__thisUnixSample)
-                                #print("__samples_to_read",self.__samples_to_read)
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                             # ojo debo anadir el readNextBLock y el  __isBufferEmpty(
                             self.dataOut.flagNoData             = False
                             buffer = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex + self.__samples_to_read]
-                            #print("test",self.__bufferIndex)
                             buffer = buffer.reshape((self.__nChannels, self.nProfileBlocks, int(self.__samples_to_read/self.nProfileBlocks)))
                             self.dataOut.nProfileBlocks = self.nProfileBlocks
                             self.dataOut.data = buffer

schainpy/model/io/jroIO_param.py +7 -3

                         #Z_SOPHy_Az40.0_20200505_14:02:15.h5
                         if self.dataOut.flagMode == 1: #'AZI' #PPI
                             ang_type = 'El'
-                            ang_    = round(numpy.mean(self.dataOut.data_ele),1)
+                            len_aux = int(self.dataOut.data_ele.shape[0]/4)
+                            mean = numpy.mean(self.dataOut.data_ele[len_aux:-len:aux])
+                            ang_    = round(mean,1)
                         elif self.dataOut.flagMode == 0: #'ELE' #RHI
                             ang_type = 'Az'
-                            ang_    = round(numpy.mean(self.dataOut.data_azi),1)
+                            len_aux = int(self.dataOut.data_azi.shape[0]/4)
+                            mean = numpy.mean(self.dataOut.data_azi[len_aux:-len:aux])
+                            ang_    = round(mean,1)
                         file = '%s%s%s%2.1f%s%2.2d%2.2d%2.2d%s%2.2d%2.2d%2.2d%s' % (wr_type,
                                                        '_SOPHy_',
                     self.filename = os.path.join( path, subfolder, file )
                     #Setting HDF5 File
-                    print("filename",self.filename)
+                    #print("filename",self.filename)
                     self.fp = h5py.File(self.filename, 'w')
                     #write metadata
                     self.writeMetadata(self.fp)

schainpy/model/proc/jroproc_parameters.py 755 ➡ 644 +95 -14

                         if hasattr(self.dataIn, 'dataPP_CCF'):
                             self.dataOut.dataPP_CCF = self.dataIn.dataPP_CCF
+                        if hasattr(self.dataIn, 'flagAskMode'):
+                            self.dataOut.flagAskMode = self.dataIn.flagAskMode
                         return
                 def setup(self,dataOut,variableList= None,Pt=0,Gt=0,Gr=0,Glna=0,lambda_=0, aL=0,
                             tauW= 0,thetaT=0,thetaR=0,Km =0):
-                    print("INICIO")
                     self.nCh      = dataOut.nChannels
                     self.nHeis    = dataOut.nHeights
                     deltaHeight   = dataOut.heightList[1] - dataOut.heightList[0]
                     self.RadarConstant = Numerator/Denominator
                     if self.variableList== None:
                         self.variableList= ['Reflectividad','ReflectividadDiferencial','CoeficienteCorrelacion','FaseDiferencial','VelocidadRadial','AnchoEspectral']
-                    print('FIN')
                 def setMoments(self,dataOut,i):
                     type  = dataOut.inputUnit
                     self.n_radar       = numpy.zeros((self.nCh,self.nHeis))
                     self.Z_radar       = numpy.zeros((self.nCh,self.nHeis))
                     for R in range(self.nHeis):
-                        self.n_radar[:,R] = self.RadarConstant*Pr[:,R]* (self.Range[:,R])**2
+                        self.n_radar[:,R] = self.RadarConstant*Pr[:,R]* (self.Range[:,R])**2*(10**-10.246)
                         self.Z_radar[:,R] = self.n_radar[:,R]* self.lambda_**4/( numpy.pi**5 * self.Km**2)
                     return Sigmav_W
-                def run(self,dataOut,variableList=variableList,Pt=0.158,Gt=38.5,Gr=38.5,Glna=70.0,lambda_=0.032, aL=1,
+                def run(self,dataOut,variableList=variableList,Pt=1.58,Gt=38.5,Gr=38.5,Glna=70.0,lambda_=0.032, aL=1,
-                            tauW= 0.2*1e-6,thetaT=0.0314,thetaR=0.0314,Km =0.93):
+                            tauW= 0.2,thetaT=0.0314,thetaR=0.0314,Km =0.93):
                     if not self.isConfig:
                         self.setup(dataOut= dataOut,variableList=variableList,Pt=Pt,Gt=Gt,Gr=Gr,Glna=Glna,lambda_=lambda_, aL=aL,
                     for i in range(len(self.variableList)):
                         if self.variableList[i]=='Reflectividad':
                             dataOut.Zdb =self.getReflectividad_D(dataOut=dataOut,type='N')
-                            print(dataOut.Zdb)
                         if self.variableList[i]=='ReflectividadDiferencial':
                             dataOut.Zdb_D =self.getReflectividad_D(dataOut=dataOut,type='D')
                         if self.variableList[i]=='FaseDiferencial':
                             log.error('No new position files found in {}'.format(path))
                             raise IOError('No new position files found in {}'.format(path))
+                def find_mode(self,index):
+                    sample_max = 20
+                    start = index
+                    flag_mode = None
+                    azi = self.fp['Data']['azi_pos'][:]
+                    ele = self.fp['Data']['ele_pos'][:]
+                    #print("az: ",az)
+                    #exit(1)
+                    while True:
+                      if start+sample_max > numpy.shape(ele)[0]:
+                        print("CANNOT KNOW IF MODE IS PPI OR RHI, ANALIZE NEXT FILE")
+                        print("ele",ele[start-sample_max:start+sample_max])
+                        print("azi",ele[start-sample_max:start+sample_max])
+                        if  sample_max == 10:
+                            break
+                        else:
+                            sample_max = 10
+                            continue
+                      sigma_ele = numpy.nanstd(ele[start:start+sample_max])
+                      sigma_azi = numpy.nanstd(azi[start:start+sample_max])
+                      print("Start",start)
+                      print("ele",ele[start:start+sample_max])
+                      print("s_ele",sigma_ele)
+                      print("azi",azi[start:start+sample_max])
+                      print("s_azi",sigma_azi)
+                      #print(start)
+                      if sigma_ele<.5 and sigma_azi<.5:
+                        if sigma_ele<sigma_azi:
+                          flag_mode = 'PPI'
+                          break
+                        else:
+                          flag_mode = 'RHI'
+                          break
+                      elif sigma_ele<.5:
+                        #print(sigma_ele)
+                        #print(round(numpy.nanmean(ele[start:start+sample_max]),1))
+                        #print(start)
+                        #print(ele[start:start+sample_max])
+                        flag_mode = 'PPI'
+                        break
+                      elif sigma_azi<.5:
+                        #print(sigma_azi)
+                        #print(azi[start:start+sample_max])
+                        #print("round",round(numpy.nanmean(azi[start:start+sample_max]),1))
+                        flag_mode = 'RHI'
+                        break
+                      #else:
+                        #print("STD mayor que .5")
+                      start += sample_max
+                    print("MODE: ",flag_mode)
+                    return flag_mode
                 def get_values(self):
                     if self.flagNoData:
-                        return numpy.nan, numpy.nan
+                        print("get_value_1")
+                        return numpy.nan, numpy.nan, numpy.nan #Should be self.mode?
                     else:
                         index = int((self.utctime-self.utcfile)/self.interval)
-                        return self.fp['Data']['azi_pos'][index], self.fp['Data']['ele_pos'][index]
+                        if self.flagAskMode:
+                            mode = self.find_mode(index)
+                        else:
+                            mode = self.mode
+                        if mode is not None:
+                            return self.fp['Data']['azi_pos'][index], self.fp['Data']['ele_pos'][index], mode
+                        else:
+                            print("get_value_2")
+                            return numpy.nan, numpy.nan, numpy.nan
                 def setup(self, dataOut, path, conf, samples, interval, az_offset):
                     if not self.isConfig:
                         self.setup(dataOut, path, conf, samples, interval, az_offset)
+                        #self.flagAskMode = True
                         self.isConfig   = True
                     self.utctime = dataOut.utctime + time_offset
+                    if hasattr(dataOut, 'flagAskMode'):
+                        self.flagAskMode = dataOut.flagAskMode
+                        #print("inside",self.flagAskMode)
+                    else:
+                        #print("nooooooo")
+                        self.flagAskMode = True
                     self.find_next_file()
-                    az, el = self.get_values()
+                    az, el, self.mode = self.get_values()
+                    print("after get_values",az,el,self.mode)
                     dataOut.flagNoData = False
                     if numpy.isnan(az) or numpy.isnan(el) :
                         dataOut.flagNoData = True
+                        #print("NAN")
                         return dataOut
                     dataOut.azimuth = az - az_offset
                     if dataOut.azimuth < 0:
                         dataOut.azimuth += 360
                     dataOut.elevation = el
+                    dataOut.mode_op = self.mode[:]
                     return dataOut
                     data_e             = None
                     angles = self.putData(data=dataOut, attr = self.attr, flagMode=flagMode)
-                    #print(angles)
+                    #print("ANGLES",angles)
                     if self.__profIndex > 1:
                         case_flag = self.checkcase(angles,flagMode)
                         if diff_angle > 0: #Subida
                             return 0
-                def run(self, dataOut, attr_data='dataPP_POWER', axis=None, runNextOp = False,**kwargs):
+                def run(self, dataOut, attr_data='dataPP_POWER', runNextOp = False,**kwargs):
                     dataOut.attr_data = attr_data
                     dataOut.runNextOp = runNextOp
+                    dataOut.flagAskMode = False
-                    dataOut.flagMode = axis[0] #Provisional, debería venir del header
+                    #print("Block 360")
+                    #dataOut.flagMode = axis[0] #Provisional, debería venir del header
+                    if dataOut.mode_op == 'PPI':
+                        dataOut.flagMode = 1
+                    elif dataOut.mode_op == 'RHI':
+                        dataOut.flagMode = 0
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, attr = attr_data ,**kwargs)
                         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)

schainpy/scripts/sophy_proc_tmp.py +2 -2

             # PATH = '/Users/jespinoza/workspace/data/'
             PARAM = {
-                'P': {'name': 'dataPP_POWER', 'zmin': 35, 'zmax': 60, 'colormap': 'viridis', 'label': 'Power', 'cb_label': 'dB'},
+                'P': {'name': 'dataPP_POWER', 'zmin': 35, 'zmax': 60, 'colormap': 'jet', 'label': 'Power', 'cb_label': 'dB'},
                 'V': {'name': 'dataPP_DOP', 'zmin': -20, 'zmax': 20, 'colormap': 'seismic', 'label': 'Velocity', 'cb_label': 'm/s'},
                 'RH': {'name': 'RhoHV_R', 'zmin': 0, 'zmax': 1, 'colormap': 'jet', 'label': 'CoeficienteCorrelacion', 'cb_label': '*'},
                 'FD': {'name': 'PhiD_P', 'zmin': -180, 'zmax': 180, 'colormap': 'RdBu_r', 'label': 'Fase Diferencial', 'cb_label': 'º'},
                 'ZD': {'name': 'Zdb_D', 'zmin': -20, 'zmax': 80, 'colormap': 'viridis', 'label': 'ReflectividadDiferencial', 'cb_label': 'dB'},
-                'Z': {'name': 'Zdb', 'zmin': 100, 'zmax': 200, 'colormap': 'viridis', 'label': 'Reflectividad', 'cb_label': 'dB'},
+                'Z': {'name': 'Zdb', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'Reflectividad', 'cb_label': 'dB'},
                 'W': {'name': 'Sigmav_W', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'AnchoEspectral', 'cb_label': 'hz'}
             }
             #Z,ZD 'mm^6/m^3'

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