schain Commit - r1384:2acdbd5998b4 · Jicamarca Repository

update change RM

avaldez -

r1384:2acdbd5998b4

parent child

Context file:

r1384:2acdbd5998b4

Collapse all files

The requested changes are too big and content was truncated. Show full diff

schainpy/model/graphics/jroplot_parameters_original.py created 644 +628 0

This diff has been collapsed as it changes many lines, (628 lines changed) Show them Hide them
	@@ -0,0 +1,628
		1	import os
		2	import datetime
		3	import numpy
		4
		5	from schainpy.model.graphics.jroplot_base import Plot, plt
		6	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
		7	from schainpy.utils import log
		8	# libreria wradlib
		9	import wradlib as wrl
		10
		11	EARTH_RADIUS = 6.3710e3
		12
		13
		14	def ll2xy(lat1, lon1, lat2, lon2):
		15
		16	p = 0.017453292519943295
		17	a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
		18	numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
		19	r = 12742 * numpy.arcsin(numpy.sqrt(a))
		20	theta = numpy.arctan2(numpy.sin((lon2-lon1)p)numpy.cos(lat2p), numpy.cos(lat1p)
		21	* numpy.sin(lat2p)-numpy.sin(lat1p)numpy.cos(lat2p)numpy.cos((lon2-lon1)p))
		22	theta = -theta + numpy.pi/2
		23	return rnumpy.cos(theta), rnumpy.sin(theta)
		24
		25
		26	def km2deg(km):
		27	'''
		28	Convert distance in km to degrees
		29	'''
		30
		31	return numpy.rad2deg(km/EARTH_RADIUS)
		32
		33
		34
		35	class SpectralMomentsPlot(SpectraPlot):
		36	'''
		37	Plot for Spectral Moments
		38	'''
		39	CODE = 'spc_moments'
		40	# colormap = 'jet'
		41	# plot_type = 'pcolor'
		42
		43	class DobleGaussianPlot(SpectraPlot):
		44	'''
		45	Plot for Double Gaussian Plot
		46	'''
		47	CODE = 'gaussian_fit'
		48	# colormap = 'jet'
		49	# plot_type = 'pcolor'
		50
		51	class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
		52	'''
		53	Plot SpectraCut with Double Gaussian Fit
		54	'''
		55	CODE = 'cut_gaussian_fit'
		56
		57	class SnrPlot(RTIPlot):
		58	'''
		59	Plot for SNR Data
		60	'''
		61
		62	CODE = 'snr'
		63	colormap = 'jet'
		64
		65	def update(self, dataOut):
		66
		67	data = {
		68	'snr': 10*numpy.log10(dataOut.data_snr)
		69	}
		70
		71	return data, {}
		72
		73	class DopplerPlot(RTIPlot):
		74	'''
		75	Plot for DOPPLER Data (1st moment)
		76	'''
		77
		78	CODE = 'dop'
		79	colormap = 'jet'
		80
		81	def update(self, dataOut):
		82
		83	data = {
		84	'dop': 10*numpy.log10(dataOut.data_dop)
		85	}
		86
		87	return data, {}
		88
		89	class PowerPlot(RTIPlot):
		90	'''
		91	Plot for Power Data (0 moment)
		92	'''
		93
		94	CODE = 'pow'
		95	colormap = 'jet'
		96
		97	def update(self, dataOut):
		98
		99	data = {
		100	'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
		101	}
		102
		103	return data, {}
		104
		105	class SpectralWidthPlot(RTIPlot):
		106	'''
		107	Plot for Spectral Width Data (2nd moment)
		108	'''
		109
		110	CODE = 'width'
		111	colormap = 'jet'
		112
		113	def update(self, dataOut):
		114
		115	data = {
		116	'width': dataOut.data_width
		117	}
		118
		119	return data, {}
		120
		121	class SkyMapPlot(Plot):
		122	'''
		123	Plot for meteors detection data
		124	'''
		125
		126	CODE = 'param'
		127
		128	def setup(self):
		129
		130	self.ncols = 1
		131	self.nrows = 1
		132	self.width = 7.2
		133	self.height = 7.2
		134	self.nplots = 1
		135	self.xlabel = 'Zonal Zenith Angle (deg)'
		136	self.ylabel = 'Meridional Zenith Angle (deg)'
		137	self.polar = True
		138	self.ymin = -180
		139	self.ymax = 180
		140	self.colorbar = False
		141
		142	def plot(self):
		143
		144	arrayParameters = numpy.concatenate(self.data['param'])
		145	error = arrayParameters[:, -1]
		146	indValid = numpy.where(error == 0)[0]
		147	finalMeteor = arrayParameters[indValid, :]
		148	finalAzimuth = finalMeteor[:, 3]
		149	finalZenith = finalMeteor[:, 4]
		150
		151	x = finalAzimuth * numpy.pi / 180
		152	y = finalZenith
		153
		154	ax = self.axes[0]
		155
		156	if ax.firsttime:
		157	ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
		158	else:
		159	ax.plot.set_data(x, y)
		160
		161	dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
		162	dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
		163	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
		164	dt2,
		165	len(x))
		166	self.titles[0] = title
		167
		168
		169	class GenericRTIPlot(Plot):
		170	'''
		171	Plot for data_xxxx object
		172	'''
		173
		174	CODE = 'param'
		175	colormap = 'viridis'
		176	plot_type = 'pcolorbuffer'
		177
		178	def setup(self):
		179	self.xaxis = 'time'
		180	self.ncols = 1
		181	self.nrows = self.data.shape('param')[0]
		182	self.nplots = self.nrows
		183	self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
		184
		185	if not self.xlabel:
		186	self.xlabel = 'Time'
		187
		188	self.ylabel = 'Range [km]'
		189	if not self.titles:
		190	self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
		191
		192	def update(self, dataOut):
		193
		194	data = {
		195	'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
		196	}
		197
		198	meta = {}
		199
		200	return data, meta
		201
		202	def plot(self):
		203	# self.data.normalize_heights()
		204	self.x = self.data.times
		205	self.y = self.data.yrange
		206	self.z = self.data['param']
		207
		208	self.z = 10*numpy.log10(self.z)
		209
		210	self.z = numpy.ma.masked_invalid(self.z)
		211
		212	if self.decimation is None:
		213	x, y, z = self.fill_gaps(self.x, self.y, self.z)
		214	else:
		215	x, y, z = self.fill_gaps(*self.decimate())
		216
		217	for n, ax in enumerate(self.axes):
		218
		219	self.zmax = self.zmax if self.zmax is not None else numpy.max(
		220	self.z[n])
		221	self.zmin = self.zmin if self.zmin is not None else numpy.min(
		222	self.z[n])
		223
		224	if ax.firsttime:
		225	if self.zlimits is not None:
		226	self.zmin, self.zmax = self.zlimits[n]
		227
		228	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		229	vmin=self.zmin,
		230	vmax=self.zmax,
		231	cmap=self.cmaps[n]
		232	)
		233	else:
		234	if self.zlimits is not None:
		235	self.zmin, self.zmax = self.zlimits[n]
		236	ax.collections.remove(ax.collections[0])
		237	ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
		238	vmin=self.zmin,
		239	vmax=self.zmax,
		240	cmap=self.cmaps[n]
		241	)
		242
		243
		244	class PolarMapPlot(Plot):
		245	'''
		246	Plot for weather radar
		247	'''
		248
		249	CODE = 'param'
		250	colormap = 'seismic'
		251
		252	def setup(self):
		253	self.ncols = 1
		254	self.nrows = 1
		255	self.width = 9
		256	self.height = 8
		257	self.mode = self.data.meta['mode']
		258	if self.channels is not None:
		259	self.nplots = len(self.channels)
		260	self.nrows = len(self.channels)
		261	else:
		262	self.nplots = self.data.shape(self.CODE)[0]
		263	self.nrows = self.nplots
		264	self.channels = list(range(self.nplots))
		265	if self.mode == 'E':
		266	self.xlabel = 'Longitude'
		267	self.ylabel = 'Latitude'
		268	else:
		269	self.xlabel = 'Range (km)'
		270	self.ylabel = 'Height (km)'
		271	self.bgcolor = 'white'
		272	self.cb_labels = self.data.meta['units']
		273	self.lat = self.data.meta['latitude']
		274	self.lon = self.data.meta['longitude']
		275	self.xmin, self.xmax = float(
		276	km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
		277	self.ymin, self.ymax = float(
		278	km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
		279	# self.polar = True
		280
		281	def plot(self):
		282
		283	for n, ax in enumerate(self.axes):
		284	data = self.data['param'][self.channels[n]]
		285
		286	zeniths = numpy.linspace(
		287	0, self.data.meta['max_range'], data.shape[1])
		288	if self.mode == 'E':
		289	azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
		290	r, theta = numpy.meshgrid(zeniths, azimuths)
		291	x, y = rnumpy.cos(theta)numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
		292	theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
		293	x = km2deg(x) + self.lon
		294	y = km2deg(y) + self.lat
		295	else:
		296	azimuths = numpy.radians(self.data.yrange)
		297	r, theta = numpy.meshgrid(zeniths, azimuths)
		298	x, y = rnumpy.cos(theta), rnumpy.sin(theta)
		299	self.y = zeniths
		300
		301	if ax.firsttime:
		302	if self.zlimits is not None:
		303	self.zmin, self.zmax = self.zlimits[n]
		304	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
		305	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
		306	vmin=self.zmin,
		307	vmax=self.zmax,
		308	cmap=self.cmaps[n])
		309	else:
		310	if self.zlimits is not None:
		311	self.zmin, self.zmax = self.zlimits[n]
		312	ax.collections.remove(ax.collections[0])
		313	ax.plt = ax.pcolormesh( # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
		314	x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
		315	vmin=self.zmin,
		316	vmax=self.zmax,
		317	cmap=self.cmaps[n])
		318
		319	if self.mode == 'A':
		320	continue
		321
		322	# plot district names
		323	f = open('/data/workspace/schain_scripts/distrito.csv')
		324	for line in f:
		325	label, lon, lat = [s.strip() for s in line.split(',') if s]
		326	lat = float(lat)
		327	lon = float(lon)
		328	# ax.plot(lon, lat, '.b', ms=2)
		329	ax.text(lon, lat, label.decode('utf8'), ha='center',
		330	va='bottom', size='8', color='black')
		331
		332	# plot limites
		333	limites = []
		334	tmp = []
		335	for line in open('/data/workspace/schain_scripts/lima.csv'):
		336	if '#' in line:
		337	if tmp:
		338	limites.append(tmp)
		339	tmp = []
		340	continue
		341	values = line.strip().split(',')
		342	tmp.append((float(values[0]), float(values[1])))
		343	for points in limites:
		344	ax.add_patch(
		345	Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
		346
		347	# plot Cuencas
		348	for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
		349	f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
		350	values = [line.strip().split(',') for line in f]
		351	points = [(float(s[0]), float(s[1])) for s in values]
		352	ax.add_patch(Polygon(points, ec='b', fc='none'))
		353
		354	# plot grid
		355	for r in (15, 30, 45, 60):
		356	ax.add_artist(plt.Circle((self.lon, self.lat),
		357	km2deg(r), color='0.6', fill=False, lw=0.2))
		358	ax.text(
		359	self.lon + (km2deg(r))numpy.cos(60numpy.pi/180),
		360	self.lat + (km2deg(r))numpy.sin(60numpy.pi/180),
		361	'{}km'.format(r),
		362	ha='center', va='bottom', size='8', color='0.6', weight='heavy')
		363
		364	if self.mode == 'E':
		365	title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
		366	label = 'E{:02d}'.format(int(self.data.meta['elevation']))
		367	else:
		368	title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
		369	label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
		370
		371	self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
		372	self.titles = ['{} {}'.format(
		373	self.data.parameters[x], title) for x in self.channels]
		374
		375	class WeatherPlot(Plot):
		376	CODE = 'weather'
		377	plot_name = 'weather'
		378	plot_type = 'ppistyle'
		379	buffering = False
		380
		381	def setup(self):
		382	self.ncols = 1
		383	self.nrows = 1
		384	self.nplots= 1
		385	self.ylabel= 'Range [Km]'
		386	self.titles= ['Weather']
		387	self.colorbar=False
		388	self.width =8
		389	self.height =8
		390	self.ini =0
		391	self.len_azi =0
		392	self.buffer_ini = None
		393	self.buffer_azi = None
		394	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
		395	self.flag =0
		396	self.indicador= 0
		397
		398	def update(self, dataOut):
		399
		400	data = {}
		401	meta = {}
		402	data['weather'] = 10numpy.log10(dataOut.data_360[0]/(250*2))
		403	data['azi'] = dataOut.data_azi
		404
		405	return data, meta
		406
		407	def plot(self):
		408	thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
		409	print("--------------------------------------",self.ini,"-----------------------------------")
		410	print("time",self.data.times[-1])
		411	data = self.data[-1]
		412	#print("debug_0", data)
		413	tmp_h = (data['weather'].shape[1])/10.0
		414	#print("debug_1",tmp_h)
		415	stoprange = float(tmp_h1.5)#stoprange = float(331.5) por ahora 400
		416	rangestep = float(0.15)
		417	r = numpy.arange(0, stoprange, rangestep)
		418	self.y = 2*r
		419	print("---------------")
		420	tmp_v = data['weather']
		421	#print("tmp_v",tmp_v.shape)
		422	tmp_z = data['azi']
		423	print("tmp_z-------------->",tmp_z)
		424	##if self.ini==0:
		425	## tmp_z= [0,1,2,3,4,5,6,7,8,9]
		426
		427	#print("tmp_z",tmp_z.shape)
		428	res = 1
		429	step = (360/(res*tmp_v.shape[0]))
		430	#print("step",step)
		431	mode = 1
		432	if mode==0:
		433	#print("self.ini",self.ini)
		434	val = numpy.mean(tmp_v[:,0])
		435	self.len_azi = len(tmp_z)
		436	ones = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
		437	self.buffer_ini = numpy.vstack((tmp_v,ones))
		438
		439	n = ((360/res)-len(tmp_z))
		440	start = tmp_z[-1]+res
		441	end = tmp_z[0]-res
		442	if start>end:
		443	end = end+360
		444	azi_zeros = numpy.linspace(start,end,int(n))
		445	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		446	self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
		447	self.ini = self.ini+1
		448
		449	if mode==1:
		450	#print("################")
		451	#print("################")
		452	#print("mode",self.ini)
		453	#print("self.ini",self.ini)
		454	if self.ini==0:
		455	res = 1
		456	step = (360/(res*tmp_v.shape[0]))
		457	val = numpy.mean(tmp_v[:,0])
		458	self.len_azi = len(tmp_z)
		459	self.buf_tmp = tmp_v
		460	ones = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
		461	self.buffer_ini = numpy.vstack((tmp_v,ones))
		462
		463	n = ((360/res)-len(tmp_z))
		464	start = tmp_z[-1]+res
		465	end = tmp_z[0]-res
		466	if start>end:
		467	end =end+360
		468	azi_zeros = numpy.linspace(start,end,int(n))
		469	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		470	self.buf_azi = tmp_z
		471	self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
		472	self.ini = self.ini+1
		473	elif 0<self.ini<step:
		474	'''
		475	if self.ini>31:
		476	start= tmp_z[0]
		477	end =tmp_z[-1]
		478	print("start","end",start,end)
		479	if self.ini==32:
		480	tmp_v=tmp_v+20
		481	if self.ini==33:
		482	tmp_v=tmp_v+10
		483	if self.ini==34:
		484	tmp_v=tmp_v+20
		485	if self.ini==35:
		486	tmp_v=tmp_v+20
		487	'''
		488	self.buf_tmp= numpy.vstack((self.buf_tmp,tmp_v))
		489	print("ERROR_INMINENTE",self.buf_tmp.shape)
		490	if self.buf_tmp.shape[0]==360:
		491	print("entre aqui en 360 grados")
		492	self.buffer_ini=self.buf_tmp
		493	else:
		494	# nuevo#########
		495	self.buffer_ini[0:self.buf_tmp.shape[0],:]=self.buf_tmp
		496	################
		497	#val=30.0
		498	#ones = numpy.ones([(360-self.buf_tmp.shape[0]),self.buf_tmp.shape[1]])*val
		499	#self.buffer_ini = numpy.vstack((self.buf_tmp,ones))
		500
		501	self.buf_azi = numpy.hstack((self.buf_azi,tmp_z))
		502	n = ((360/res)-len(self.buf_azi))
		503	print("n----->",n)
		504	if n==0:
		505	self.buffer_ini_azi = self.buf_azi
		506	else:
		507	start = self.buf_azi[-1]+res
		508	end = self.buf_azi[0]-res
		509	print("start",start)
		510	print("end",end)
		511	if start>end:
		512	end =end+360
		513	azi_zeros = numpy.linspace(start,end,int(n))
		514	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		515	print("self.buf_azi",self.buf_azi[0])
		516	print("tmp_Z 0 ",tmp_z[0])
		517	print("tmp_Z -1",tmp_z[-1])
		518	if tmp_z[0]<self.buf_azi[0] <tmp_z[-1]:
		519	print("activando indicador")
		520	self.indicador=1
		521	if self.indicador==1:
		522	azi_zeros = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
		523	###start = tmp_z[-1]+res
		524	###end = tmp_z[0]-res
		525	###if start>end:
		526	### end =end+360
		527	###azi_zeros = numpy.linspace(start,end,int(n))
		528	###azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		529	#print("azi_zeros",azi_zeros)
		530
		531	######self.buffer_ini_azi = numpy.hstack((self.buf_azi,azi_zeros))
		532	#self.buffer_ini[0:tmv.shape[0],:]=tmp_v
		533	##self.indicador=0
		534
		535	# self.indicador = True
		536	#if self.indicador==True:
		537	# azi_zeros = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
		538
		539	#self.buf_azi = tmp_z
		540	self.buffer_ini_azi = numpy.hstack((self.buf_azi,azi_zeros))
		541
		542	if self.ini==step-1:
		543	start= tmp_z[0]
		544	end = tmp_z[-1]
		545	#print("start","end",start,end)
		546	###print(self.buffer_ini_azi[:80])
		547	self.ini = self.ini+1
		548
		549	else:
		550	step = (360/(res*tmp_v.shape[0]))
		551	# aqui estaba realizando el debug de simulacion
		552	# tmp_v=tmp_v +5 en cada step sumaba 5
		553	# y el mismo valor despues de la primera vuelta
		554	#tmp_v=tmp_v+5+(self.ini-step)*1### aqui yo habia sumado 5 por las puras
		555
		556	start= tmp_z[0]
		557	end = tmp_z[-1]
		558	#print("start","end",start,end)
		559	###print(self.buffer_ini_azi[:120])
		560
		561	if step>=2:
		562	if self.flag<step-1:
		563	limit_i=self.buf_azi[len(tmp_z)*(self.flag+1)]
		564	limit_s=self.buf_azi[len(tmp_z)*(self.flag+2)-1]
		565	print("flag",self.flag,limit_i,limit_s)
		566	if limit_i< tmp_z[-1]< limit_s:
		567	index_i=int(numpy.where(tmp_z<=self.buf_azi[len(tmp_z)*(self.flag+1)])[0][-1])
		568	tmp_r =int(numpy.where(self.buf_azi[(self.flag+1)len(tmp_z):(self.flag+2)len(tmp_z)]>=tmp_z[-1])[0][0])
		569	print("tmp_r",tmp_r)
		570	index_f=(self.flag+1)*len(tmp_z)+tmp_r
		571
		572	if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f]):
		573	final = len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f])
		574	else:
		575	final= len(tmp_z[index_i:])
		576	self.buf_azi[len(tmp_z)*(self.flag+1):index_f]=tmp_z[index_i:index_i+final]
		577	self.buf_tmp[len(tmp_z)*(self.flag+1):index_f,:]=tmp_v[index_i:index_i+final,:]
		578	if limit_i<tmp_z[0]<limit_s:
		579	index_f =int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
		580	n_p =index_f-len(tmp_z)*(self.flag+1)
		581	if n_p>0:
		582	self.buf_azi[len(tmp_z)(self.flag+1):index_f]=tmp_z[-1]numpy.ones(n_p)
		583	self.buf_tmp[len(tmp_z)(self.flag+1):index_f,:]=tmp_v[-1,:]numpy.ones([n_p,tmp_v.shape[1]])
		584
		585	'''
		586	if self.buf_azi[len(tmp_z)]<tmp_z[-1]<self.buf_azi[2*len(tmp_z)-1]:
		587	index_i= int(numpy.where(tmp_z <= self.buf_azi[len(tmp_z)])[0][-1])
		588	index_f= int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
		589	#print("index",index_i,index_f)
		590	if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z):index_f]):
		591	final = len(self.buf_azi[len(tmp_z):index_f])
		592	else:
		593	final = len(tmp_z[index_i:])
		594	self.buf_azi[len(tmp_z):index_f]=tmp_z[index_i:index_i+final]
		595	self.buf_tmp[len(tmp_z):index_f,:]=tmp_v[index_i:index_i+final,:]
		596	'''
		597	self.buf_tmp[len(tmp_z)(self.flag):len(tmp_z)(self.flag+1),:]=tmp_v
		598	self.buf_azi[len(tmp_z)(self.flag):len(tmp_z)(self.flag+1)] = tmp_z
		599	self.buffer_ini=self.buf_tmp
		600	self.buffer_ini_azi = self.buf_azi
		601	##print("--------salida------------")
		602	start= tmp_z[0]
		603	end = tmp_z[-1]
		604	##print("start","end",start,end)
		605	##print(self.buffer_ini_azi[:120])
		606	self.ini= self.ini+1
		607	self.flag = self.flag +1
		608	if self.flag==step:
		609	self.flag=0
		610	numpy.set_printoptions(suppress=True)
		611	print("buffer_ini_azi")
		612	print(self.buffer_ini_azi[:20])
		613	print(self.buffer_ini_azi[-40:])
		614	for i,ax in enumerate(self.axes):
		615	if ax.firsttime:
		616	plt.clf()
		617	cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
		618	else:
		619	plt.clf()
		620	cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
		621	caax = cgax.parasites[0]
		622	paax = cgax.parasites[1]
		623	cbar = plt.gcf().colorbar(pm, pad=0.075)
		624	caax.set_xlabel('x_range [km]')
		625	caax.set_ylabel('y_range [km]')
		626	plt.text(1.0, 1.05, 'azimuth '+str(thisDatetime)+"step"+str(self.ini), transform=caax.transAxes, va='bottom',ha='right')
		627	#import time
		628	#time.sleep(0.5)

schainpy/model/graphics/jroplot_parameters.py +91 -200

             import os
             import datetime
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             # libreria wradlib
             import wradlib as wrl
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DobleGaussianPlot(SpectraPlot):
                 '''
                 Plot for Double Gaussian Plot
                 '''
                 CODE = 'gaussian_fit'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
                 '''
                 Plot SpectraCut with Double Gaussian Fit
                 '''
                 CODE = 'cut_gaussian_fit'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'snr': 10*numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'dop': 10*numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
                     }
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'width': dataOut.data_width
                     }
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Range [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = 10*numpy.log10(self.z)
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     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.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     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.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     self.colorbar=False
                     self.width   =8
                     self.height  =8
                     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
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(250**2))
+                    print(data['weather'])
                     data['azi']     = dataOut.data_azi
+                    print("UPDATE",data['azi'])
                     return data, meta
-                def plot(self):
+                def const_ploteo(self,data_weather,data_azi,step,res):
-                    thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
+                    #print("data_weather",data_weather)
-                    print("--------------------------------------",self.ini,"-----------------------------------")
+                    print("data_azi",data_azi)
-                    print("time",self.data.times[-1])
+                    print("step",step)
-                    data   = self.data[-1]
-                    #print("debug_0", data)
-                    tmp_h     = (data['weather'].shape[1])/10.0
-                    #print("debug_1",tmp_h)
-                    stoprange = float(tmp_h*1.5)#stoprange = float(33*1.5) por ahora 400
-                    rangestep = float(0.15)
-                    r      = numpy.arange(0, stoprange, rangestep)
-                    self.y = 2*r
-                    print("---------------")
-                    tmp_v  = data['weather']
-                    #print("tmp_v",tmp_v.shape)
-                    tmp_z  = data['azi']
-                    print("tmp_z-------------->",tmp_z)
-                    ##if self.ini==0:
-                    ##    tmp_z= [0,1,2,3,4,5,6,7,8,9]
-                    #print("tmp_z",tmp_z.shape)
-                    res             = 1
-                    step   = (360/(res*tmp_v.shape[0]))
-                    #print("step",step)
-                    mode   = 1
-                    if mode==0:
-                        #print("self.ini",self.ini)
-                        val             = numpy.mean(tmp_v[:,0])
-                        self.len_azi    = len(tmp_z)
-                        ones            = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
-                        self.buffer_ini = numpy.vstack((tmp_v,ones))
-                        n      = ((360/res)-len(tmp_z))
-                        start  = tmp_z[-1]+res
-                        end    = tmp_z[0]-res
-                        if start>end:
-                            end = end+360
-                        azi_zeros           = numpy.linspace(start,end,int(n))
-                        azi_zeros           = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
-                        self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
-                        self.ini            = self.ini+1
-                    if mode==1:
-                        #print("################")
-                        #print("################")
-                        #print("mode",self.ini)
-                        #print("self.ini",self.ini)
                     if self.ini==0:
-                            res             = 1
+                        #------- AZIMUTH
-                            step            = (360/(res*tmp_v.shape[0]))
+                        n     = (360/res)-len(data_azi)
-                            val             = numpy.mean(tmp_v[:,0])
+                        start = data_azi[-1] + res
-                            self.len_azi    = len(tmp_z)
+                        end   = data_azi[0]  - res
-                            self.buf_tmp    = tmp_v
-                            ones            = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
-                            self.buffer_ini = numpy.vstack((tmp_v,ones))
-                            n      = ((360/res)-len(tmp_z))
-                            start  = tmp_z[-1]+res
-                            end    = tmp_z[0]-res
                         if start>end:
                             end        = end + 360
-                            azi_zeros           = numpy.linspace(start,end,int(n))
+                        azi_vacia = numpy.linspace(start,end,int(n))
-                            azi_zeros           = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
+                        azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
-                            self.buf_azi        = tmp_z
+                        data_azi  = numpy.hstack((data_azi,azi_vacia))
-                            self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
+                        # RADAR
-                            self.ini            = self.ini+1
+                        val_mean         = numpy.mean(data_weather[:,0])
-                        elif 0<self.ini<step:
+                        data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
-                            '''
+                        data_weather     = numpy.vstack((data_weather,data_weather_cmp))
-                            if self.ini>31:
-                                start= tmp_z[0]
-                                end  =tmp_z[-1]
-                                print("start","end",start,end)
-                            if self.ini==32:
-                                tmp_v=tmp_v+20
-                            if self.ini==33:
-                                tmp_v=tmp_v+10
-                            if self.ini==34:
-                                tmp_v=tmp_v+20
-                            if self.ini==35:
-                                tmp_v=tmp_v+20
-                            '''
-                            self.buf_tmp= numpy.vstack((self.buf_tmp,tmp_v))
-                            print("ERROR_INMINENTE",self.buf_tmp.shape)
-                            if self.buf_tmp.shape[0]==360:
-                                print("entre aqui en 360 grados")
-                                self.buffer_ini=self.buf_tmp
                     else:
-                                # nuevo#########
+                        # azimuth
-                                self.buffer_ini[0:self.buf_tmp.shape[0],:]=self.buf_tmp
+                        flag=0
-                                ################
+                        start_azi = self.res_azi[0]
-                                #val=30.0
+                        start = data_azi[0]
-                                #ones            = numpy.ones([(360-self.buf_tmp.shape[0]),self.buf_tmp.shape[1]])*val
+                        end   = data_azi[-1]
-                                #self.buffer_ini = numpy.vstack((self.buf_tmp,ones))
-                            self.buf_azi    = numpy.hstack((self.buf_azi,tmp_z))
-                            n      = ((360/res)-len(self.buf_azi))
-                            print("n----->",n)
-                            if n==0:
-                                self.buffer_ini_azi = self.buf_azi
-                            else:
-                                start  = self.buf_azi[-1]+res
-                                end    = self.buf_azi[0]-res
                         print("start",start)
                         print("end",end)
-                                if start>end:
+                        if start< start_azi:
+                            start = start +360
+                        if end <start_azi:
                             end  = end +360
-                                azi_zeros           = numpy.linspace(start,end,int(n))
-                                azi_zeros           = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
-                                print("self.buf_azi",self.buf_azi[0])
-                                print("tmp_Z 0 ",tmp_z[0])
-                                print("tmp_Z -1",tmp_z[-1])
-                                if tmp_z[0]<self.buf_azi[0] <tmp_z[-1]:
-                                    print("activando indicador")
-                                    self.indicador=1
-                                if self.indicador==1:
-                                    azi_zeros           = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
-                                    ###start  = tmp_z[-1]+res
-                                    ###end    = tmp_z[0]-res
-                                    ###if start>end:
-                                    ###    end =end+360
-                                    ###azi_zeros           = numpy.linspace(start,end,int(n))
-                                    ###azi_zeros           = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
-                                    print("azi_zeros",azi_zeros)
-                                    ######self.buffer_ini_azi = numpy.hstack((self.buf_azi,azi_zeros))
-                                    #self.buffer_ini[0:tmv.shape[0],:]=tmp_v
-                                    ##self.indicador=0
-                                #    self.indicador = True
-                                #if self.indicador==True:
-                                #    azi_zeros           = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
-                                #self.buf_azi        = tmp_z
-                                self.buffer_ini_azi = numpy.hstack((self.buf_azi,azi_zeros))
-                            if self.ini==step-1:
-                                start= tmp_z[0]
-                                end  = tmp_z[-1]
-                                #print("start","end",start,end)
-                                ###print(self.buffer_ini_azi[:80])
-                            self.ini            = self.ini+1
+                        print("start",start)
+                        print("end",end)
+                        #### AQUI SERA LA MAGIA
+                        pos_ini = int((start-start_azi)/res)
+                        len_azi = len(data_azi)
+                        if (360-pos_ini)<len_azi:
+                            if pos_ini+1==360:
+                                pos_ini=0
                             else:
-                            step   = (360/(res*tmp_v.shape[0]))
+                                flag=1
-                            # aqui estaba realizando el debug de simulacion
+                                dif= 360-pos_ini
-                            # tmp_v=tmp_v +5 en cada step sumaba 5
+                                comp= len_azi-dif
-                            # y el mismo valor despues de la primera vuelta
-                            #tmp_v=tmp_v+5+(self.ini-step)*1### aqui yo habia sumado 5 por las puras
+                        print(pos_ini)
+                        print(len_azi)
-                            start= tmp_z[0]
+                        print("shape",self.res_azi.shape)
-                            end  = tmp_z[-1]
+                        if flag==0:
-                            #print("start","end",start,end)
+                            # AZIMUTH
-                            ###print(self.buffer_ini_azi[:120])
+                            self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
+                            # RADAR
-                            if step>=2:
+                            self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
-                                if self.flag<step-1:
-                                    limit_i=self.buf_azi[len(tmp_z)*(self.flag+1)]
-                                    limit_s=self.buf_azi[len(tmp_z)*(self.flag+2)-1]
-                                    print("flag",self.flag,limit_i,limit_s)
-                                    if limit_i< tmp_z[-1]< limit_s:
-                                        index_i=int(numpy.where(tmp_z<=self.buf_azi[len(tmp_z)*(self.flag+1)])[0][-1])
-                                        tmp_r    =int(numpy.where(self.buf_azi[(self.flag+1)*len(tmp_z):(self.flag+2)*len(tmp_z)]>=tmp_z[-1])[0][0])
-                                        print("tmp_r",tmp_r)
-                                        index_f=(self.flag+1)*len(tmp_z)+tmp_r
-                                        if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f]):
-                                            final = len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f])
                         else:
-                                            final= len(tmp_z[index_i:])
+                            # AZIMUTH
-                                        self.buf_azi[len(tmp_z)*(self.flag+1):index_f]=tmp_z[index_i:index_i+final]
+                            self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
-                                        self.buf_tmp[len(tmp_z)*(self.flag+1):index_f,:]=tmp_v[index_i:index_i+final,:]
+                            self.res_azi[0:comp]              = data_azi[dif:]
-                                    if limit_i<tmp_z[0]<limit_s:
+                            # RADAR
-                                        index_f =int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
+                            self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
-                                        n_p =index_f-len(tmp_z)*(self.flag+1)
+                            self.res_weather[0:comp,:]              = data_weather[dif:,:]
-                                        if n_p>0:
+                            flag=0
-                                            self.buf_azi[len(tmp_z)*(self.flag+1):index_f]=tmp_z[-1]*numpy.ones(n_p)
+                        data_azi                                    = self.res_azi
-                                            self.buf_tmp[len(tmp_z)*(self.flag+1):index_f,:]=tmp_v[-1,:]*numpy.ones([n_p,tmp_v.shape[1]])
+                        data_weather                                = self.res_weather
+                    return data_weather,data_azi
+                def plot(self):
+                    print("--------------------------------------",self.ini,"-----------------------------------")
+                    #numpy.set_printoptions(suppress=True)
+                    #print(self.data.times)
+                    thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
+                    data         = self.data[-1]
+                    # ALTURA altura_tmp_h
+                    altura_h     = (data['weather'].shape[1])/10.0
+                    stoprange = float(altura_h*1.5)#stoprange = float(33*1.5) por ahora 400
+                    rangestep = float(0.15)
+                    r      = numpy.arange(0, stoprange, rangestep)
+                    self.y = 2*r
+                    # RADAR
+                    #data_weather = data['weather']
+                    # PEDESTAL
+                    #data_azi  = data['azi']
+                    res     = 1
+                    # STEP
+                    step    = (360/(res*data['weather'].shape[0]))
+                    #print("shape wr_data", wr_data.shape)
+                    #print("shape wr_azi",wr_azi.shape)
+                    #print("step",step)
+                    print("Time---->",self.data.times[-1],thisDatetime)
+                    #print("alturas", len(self.y))
+                    self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'],data_azi=data['azi'],step=step,res=res)
+                    #numpy.set_printoptions(suppress=True)
+                    #print("resultado",self.res_azi)
+                    ##########################################################
+                    #################    PLOTEO           ###################
+                    ##########################################################
-                            '''
-                                    if self.buf_azi[len(tmp_z)]<tmp_z[-1]<self.buf_azi[2*len(tmp_z)-1]:
-                                        index_i= int(numpy.where(tmp_z  <=  self.buf_azi[len(tmp_z)])[0][-1])
-                                        index_f= int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
-                                        #print("index",index_i,index_f)
-                                        if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z):index_f]):
-                                            final = len(self.buf_azi[len(tmp_z):index_f])
-                                        else:
-                                            final = len(tmp_z[index_i:])
-                                        self.buf_azi[len(tmp_z):index_f]=tmp_z[index_i:index_i+final]
-                                        self.buf_tmp[len(tmp_z):index_f,:]=tmp_v[index_i:index_i+final,:]
-                            '''
-                            self.buf_tmp[len(tmp_z)*(self.flag):len(tmp_z)*(self.flag+1),:]=tmp_v
-                            self.buf_azi[len(tmp_z)*(self.flag):len(tmp_z)*(self.flag+1)] = tmp_z
-                            self.buffer_ini=self.buf_tmp
-                            self.buffer_ini_azi = self.buf_azi
-                            ##print("--------salida------------")
-                            start= tmp_z[0]
-                            end  = tmp_z[-1]
-                            ##print("start","end",start,end)
-                            ##print(self.buffer_ini_azi[:120])
-                            self.ini= self.ini+1
-                            self.flag = self.flag +1
-                            if self.flag==step:
-                                self.flag=0
-                    numpy.set_printoptions(suppress=True)
-                    print("buffer_ini_azi")
-                    print(self.buffer_ini_azi)
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             plt.clf()
-                            cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
+                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
                         else:
                             plt.clf()
-                            cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
+                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
                     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), transform=caax.transAxes, va='bottom',ha='right')
-                    #import time
-                    #time.sleep(0.5)
+                    self.ini= self.ini+1

schainpy/model/proc/jroproc_base.py +6 -3

             '''
             Base clases to create Processing units and operations, the MPDecorator
             must be used in plotting and writing operations to allow to run as an
             external process.
             '''
             import inspect
             import zmq
             import time
             import pickle
             import traceback
             from threading import Thread
             from multiprocessing import Process, Queue
             from schainpy.utils import log
             class ProcessingUnit(object):
                 '''
                 Base class to create Signal Chain Units
                 '''
                 proc_type = 'processing'
                 def __init__(self):
                     self.dataIn = None
                     self.dataOut = None
                     self.isConfig = False
                     self.operations = []
                 def setInput(self, unit):
                     self.dataIn = unit.dataOut
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def addOperation(self, conf, operation):
                     '''
                     '''
                     self.operations.append((operation, conf.type, conf.getKwargs()))
                 def getOperationObj(self, objId):
                     if objId not in list(self.operations.keys()):
                         return None
                     return self.operations[objId]
                 def call(self, **kwargs):
                     '''
                     '''
                     try:
                         if self.dataIn is not None and self.dataIn.flagNoData and not self.dataIn.error:
                             return self.dataIn.isReady()
                         elif self.dataIn is None or not self.dataIn.error:
                             self.run(**kwargs)
                         elif self.dataIn.error:
                             self.dataOut.error = self.dataIn.error
                             self.dataOut.flagNoData = True
                     except:
                         err = traceback.format_exc()
                         if 'SchainWarning' in err:
                             log.warning(err.split('SchainWarning:')[-1].split('\n')[0].strip(), self.name)
                         elif 'SchainError' in err:
                             log.error(err.split('SchainError:')[-1].split('\n')[0].strip(), self.name)
                         else:
                             log.error(err, self.name)
                         self.dataOut.error = True
+                    ##### correcion de la declaracion Out
                     for op, optype, opkwargs in self.operations:
+                        aux = self.dataOut.copy()
                         if optype == 'other' and not self.dataOut.flagNoData:
                             self.dataOut = op.run(self.dataOut, **opkwargs)
                         elif optype == 'external' and not self.dataOut.flagNoData:
-                            op.queue.put(self.dataOut)
+                            #op.queue.put(self.dataOut)
+                            op.queue.put(aux)
                         elif optype == 'external' and self.dataOut.error:
-                            op.queue.put(self.dataOut)
+                            #op.queue.put(self.dataOut)
+                            op.queue.put(aux)
                     return 'Error' if self.dataOut.error else self.dataOut.isReady()
                 def setup(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def close(self):
                     return
             class Operation(object):
                 '''
                 '''
                 proc_type = 'operation'
                 def __init__(self):
                     self.id = None
                     self.isConfig = False
                     if not hasattr(self, 'name'):
                         self.name = self.__class__.__name__
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def setup(self):
                     self.isConfig = True
                     raise NotImplementedError
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los
                     atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     if not self.isConfig:
                         self.setup(**kwargs)
                     raise NotImplementedError
                 def close(self):
                     return
             def MPDecorator(BaseClass):
                 """
                 Multiprocessing class decorator
                 This function add multiprocessing features to a BaseClass.
                 """
                 class MPClass(BaseClass, Process):
                     def __init__(self, *args, **kwargs):
                         super(MPClass, self).__init__()
                         Process.__init__(self)
                         self.args = args
                         self.kwargs = kwargs
                         self.t = time.time()
                         self.op_type = 'external'
                         self.name = BaseClass.__name__
                         self.__doc__ = BaseClass.__doc__
                         if 'plot' in self.name.lower() and not self.name.endswith('_'):
                             self.name = '{}{}'.format(self.CODE.upper(), 'Plot')
                         self.start_time = time.time()
                         self.err_queue = args[3]
                         self.queue = Queue(maxsize=1)
                         self.myrun = BaseClass.run
                     def run(self):
                         while True:
                             dataOut = self.queue.get()
                             if not dataOut.error:
                                 try:
                                     BaseClass.run(self, dataOut, **self.kwargs)
                                 except:
                                     err = traceback.format_exc()
                                     log.error(err, self.name)
                             else:
                                 break
                         self.close()
                     def close(self):
                         BaseClass.close(self)
                         log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
                 return MPClass

schainpy/model/proc/jroproc_parameters.py 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

schainpy/scripts/USRP_ADQ_PP.py +23 -3

             #!python
             '''
             '''
             import os, sys
             import datetime
             import time
             #path = os.path.dirname(os.getcwd())
             #path = os.path.dirname(path)
             #sys.path.insert(0, path)
             from schainpy.controller import Project
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
             #######################################################################
             ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
             #######################################################################
             #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman'
             #path = '/DATA_RM/TEST_INTEGRACION'
             #path = '/DATA_RM/TEST_ONLINE'
-            path = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
+            #path = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
-            path_pp = '/DATA_RM/TEST_HDF5'
+            # ULTIMO TEST 22 DE SEPTIEMBRE
+            path = '/DATA_RM/USRP_22'
+            #path_pp = '/DATA_RM/TEST_HDF5'
+            # UTIMO TEST 22 DE SEPTIEMBRE
+            path_pp = '/DATA_RM/TEST_HDF5_PP_22'
+            ######################################################
+            ##### OJO TENER EN CUENTA EL n= para el Pulse Pair ###
+            ######################################################
+            ######## BUSCAMOS EL numero de IPP equivalente 1°#####
+            ######## Sea V la velocidad del Pedestal en °/seg#####
+            ######## 1° sera Recorrido en un tiempo de  1/V ######
+            ######## IPP del Radar 400 useg --> 60 Km ############
+            ######## n   = 1/(V*IPP) , NUMERO DE IPP #############
+            ######## n   = 1/(V*IPP) #############################
+            V=2
+            IPP=400*1e-6
+            n= 1/(V*IPP)
+            print("n numero de Perfiles a procesar con Pulse Pair: ", n)
             figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
             dBmin = '-5'
             dBmax = '20'
             xmin = '0'
             xmax ='24'
             ymin = '0'
             ymax = '600'
             #######################################################################
             ########################FECHA##########################################
             #######################################################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
                                                         startDate="2021/01/01",#today,
                                                         endDate="2021/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
             #######################################################################
             ################ OPERACIONES DOMINIO DEL TIEMPO########################
             #######################################################################
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             #
             # codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\
             #              '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1'
             #opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
             #opObj11.addParameter(name='frequency', value='70312500')
             opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
-            opObj11.addParameter(name='n', value='16', format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
+            opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
             opObj11.addParameter(name='removeDC', value=1, format='int')
             # Ploteo TEST
             '''
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
             #opObj11.addParameter(name='xmax', value=8)
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
             '''
             # OJO SCOPE
             #opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
             #opObj10.addParameter(name='id', value='10', format='int')
             ##opObj10.addParameter(name='xmin', value='0', format='int')
             ##opObj10.addParameter(name='xmax', value='50', format='int')
             #opObj10.addParameter(name='type', value='iq')
             ##opObj10.addParameter(name='ymin', value='-5000', format='int')
             ##opObj10.addParameter(name='ymax', value='8500', format='int')
             #opObj11.addParameter(name='save', value=figpath, format='str')
             #opObj11.addParameter(name='save_period', value=10, format='int')
             #opObj10 = procUnitConfObjA.addOperation(name='setH0')
             #opObj10.addParameter(name='h0', value='-5000', format='float')
             #opObj11 =  procUnitConfObjA.addOperation(name='filterByHeights')
             #opObj11.addParameter(name='window', value='1', format='int')
             #codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1'
             #opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
             #opObj11.addParameter(name='code', value=codigo, formatyesterday='floatlist')
             #opObj11.addParameter(name='nCode', value='1', format='int')
             #opObj11.addParameter(name='nBaud', value='28', format='int')
             #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
             #opObj11.addParameter(name='n', value='100', format='int')
             #######################################################################
             ########## OPERACIONES ParametersProc########################
             #######################################################################
             procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
             opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
             opObj10.addParameter(name='path',value=path_pp)
             #opObj10.addParameter(name='mode',value=0)
             opObj10.addParameter(name='blocksPerFile',value='100',format='int')
             opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
             opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
             controllerObj.start()

schainpy/scripts/USRP_ADQ_SPECM.py +17 -6

             #!python
             '''
             '''
             import os, sys
             import datetime
             import time
             #path = os.path.dirname(os.getcwd())
             #path = os.path.dirname(path)
             #sys.path.insert(0, path)
             from schainpy.controller import Project
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
             #######################################################################
             ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
             #######################################################################
             #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman'
             #path = '/DATA_RM/TEST_INTEGRACION'
             #path = '/DATA_RM/TEST_ONLINE'
             #path_pp = '/DATA_RM/TEST_HDF5'
             #figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
-            path = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
+            ###path = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
-            path_pp = '/DATA_RM/TEST_HDF5_SPEC'
+            ###path_pp = '/DATA_RM/TEST_HDF5_SPEC'
+            #path = '/DATA_RM/USRP_22'
+            path = '/DATA_RM/23/6v'
+            #path_pp = '/DATA_RM/TEST_HDF5'
+            # UTIMO TEST 22 DE SEPTIEMBRE
+            #path_pp = '/DATA_RM/TEST_HDF5_SPEC_22'
+            #path_pp = '/DATA_RM/TEST_HDF5_SPEC_3v'
+            path_pp = '/DATA_RM/TEST_HDF5_SPEC_23/6v'
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
             dBmin = '-5'
             dBmax = '20'
             xmin = '0'
             xmax ='24'
             ymin = '0'
             ymax = '600'
             #######################################################################
             ########################FECHA##########################################
             #######################################################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
                                                         startDate="2021/01/01",#today,
                                                         endDate="2021/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
             #######################################################################
             ################ OPERACIONES DOMINIO DEL TIEMPO########################
             #######################################################################
+            V=6
+            IPP=400*1e-6
+            n= int(1/(V*IPP))
+            print("n numero de Perfiles a procesar con nFFTPoints ", n)
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
-            procUnitConfObjB.addParameter(name='nFFTPoints', value=250, format='int')
+            procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
-            procUnitConfObjB.addParameter(name='nProfiles' , value=250, format='int')
+            procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
             #
             # codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\
             #              '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1'
             #opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
             #opObj11.addParameter(name='frequency', value='70312500')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
             #opObj11.addParameter(name='n', value='625', format='int')#10
             #opObj11.addParameter(name='removeDC', value=1, format='int')
             # Ploteo TEST
             '''
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
             #opObj11.addParameter(name='xmax', value=8)
             opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
             '''
             # OJO SCOPE
             #opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
             #opObj10.addParameter(name='buffer_sizeid', value='10', format='int')
             ##opObj10.addParameter(name='xmin', value='0', format='int')
             ##opObj10.addParameter(name='xmax', value='50', format='int')
             #opObj10.addParameter(name='type', value='iq')
             ##opObj10.addParameter(name='ymin', value='-5000', format='int')
             ##opObj10.addParameter(name='ymax', value='8500', format='int')
             #opObj11.addParameter(name='save', value=figpath, format='str')
             #opObj11.addParameter(name='save_period', value=10, format='int')
             #opObj10 = procUnitConfObjA.addOperation(name='setH0')
             #opObj10.addParameter(name='h0', value='-5000', format='float')
             #opObj11 =  procUnitConfObjA.addOperation(name='filterByHeights')
             #opObj11.addParameter(name='window', value='1', format='int')
             #codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1'
             #opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
             #opObj11.addParameter(name='code', value=codigo, formatyesterday='floatlist')
             #opObj11.addParameter(name='nCode', value='1', format='int')
             #opObj11.addParameter(name='nBaud', value='28', format='int')
             #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
             #opObj11.addParameter(name='n', value='100', format='int')
             #######################################################################
             ########## OPERACIONES ParametersProc########################
             #######################################################################
             procUnitConfObjC= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
             procUnitConfObjC.addOperation(name='SpectralMoments')
             opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
             opObj10.addParameter(name='path',value=path_pp)
             #opObj10.addParameter(name='mode',value=0)
             opObj10.addParameter(name='blocksPerFile',value='100',format='int')
             #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
             opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
             opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
             controllerObj.start()

schainpy/scripts/WR_PROC_PP_PLOT_OFFLINE.py +16 -5

             import os,sys
             import datetime
             import time
             from schainpy.controller import Project
             #path='/DATA_RM/TEST_HDF5/d2021200'
             #path='/DATA_RM/TEST_HDF5/d2021200'
             #path='/DATA_RM/TEST_HDF5/d2021214'
             #path='/DATA_RM/TEST_HDF5/d2021229'
             #path='/DATA_RM/TEST_HDF5/d2021231'
             #path='/DATA_RM/TEST_HDF5/ADQ_OFFLINE/d2021231'
             path='/DATA_RM/TEST_HDF5/d2021231'
+            #path='/DATA_RM/TEST_14_HDF5/d2021257'
+            ## TEST ULTIMA PRUEBA 22 DE SEPTIEMBRE
+            path = '/DATA_RM/TEST_HDF5_PP_22/d2021265'
             path_adq=path
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021200'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021214'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021230'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20210819'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20210819-154315'
-            path_ped='/DATA_RM/TEST_PEDESTAL/PEDESTAL_OFFLINE/P20210819-161524'
+            #path_ped='/DATA_RM/TEST_PEDESTAL/P20210914-162434'
+            #path_ped='/DATA_RM/TEST_PEDESTAL/PEDESTAL_OFFLINE/P20210819-161524'
+            #pruebas con perdida de datos
+            #path_ped='/DATA_RM/TEST_PEDESTAL/PEDESTAL_OFFLINE/P20210819-161524_TEST'
+            ## TEST ULTIMA PRUEBA 22 DE SEPTIEMBRE
+            path_ped='/DATA_RM/TEST_PEDESTAL/P20210922-122731'
             figpath = '/home/soporte/Pictures'
             desc            = "Simulator Test"
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
                                                         path=path,
                                                         startDate="2021/01/01",   #"2020/01/01",#today,
                                                         endDate= "2021/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         t_Interval_p=0.01,
                                                         n_Muestras_p=100,
                                                         delay=30,
                                                         #set=0,
                                                         online=0,
                                                         walk=0,
                                                         nTries=6)#1
             procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
+            V=2
+            blocksPerfile=100
+            print("Velocidad del Pedestal",V)
+            f_a_p= int(blocksPerfile/V)
             opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
             opObj11.addParameter(name='path_ped', value=path_ped)
             opObj11.addParameter(name='path_adq', value=path_adq)
             opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
             opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
             opObj11.addParameter(name='blocksPerfile', value='100', format='int')
-            opObj11.addParameter(name='f_a_p', value='10', format='int')
+            opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
             opObj11.addParameter(name='online', value='0', format='int')# habilitar el enable aqui tambien
             opObj11 = procUnitConfObjA.addOperation(name='Block360')
             opObj11.addParameter(name='n', value='10', format='int')
             # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
             opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
-            opObj11.addParameter(name='save', value=figpath)
+            #opObj11.addParameter(name='save', value=figpath)
-            opObj11.addParameter(name='save_period', value=1)
+            #opObj11.addParameter(name='save_period', value=1)
             controllerObj.start()
             #online 1 utc_adq 1617490240.48
             #online 0 utc_adq 1617489815.4804

schainpy/scripts/test_sim00011a2.py +5 -4

             import os,sys,json
             import datetime
             import time
             from schainpy.controller import Project
             '''
             NOTA:
             Este script de prueba.
             - Unidad del lectura 'HDFReader'.
             - Unidad de procesamiento ParametersProc
             - Operacion SpectralMomentsPlot
             '''
             #path       = '/home/soporte/Downloads/RAWDATA_PP'
             #path       = '/DATA_RM/TEST_HDF5/d2021203'
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
             dBmin = '1'
             dBmax = '85'
             xmin = '0'
             xmax ='24'
-            tmmin = 16.2
+            tmmin = 12.2
-            tmmax = 16.25
+            tmmax = 12.40
             ymin = '0'
             ymax = '600'
             #######################################################################
             #######################################################################
             # este script lee los archivos pre-procesados pulse-pair y permite el
             # el ploteo del rti, mostrando los valores de potencia  de la senal.
             # el resultado del grafico depende del programa USRP_ADQ_PP.py
             # debido al procesamiento del Pulse Pair.
             #######################################################################
             #######################################################################
+            #path_pp = '/DATA_RM/TEST_HDF5_PP_22'
-            path='/DATA_RM/TEST_HDF5/d2021231'
+            path='/DATA_RM/TEST_HDF5_PP_22/d2021265'
+            #path='/DATA_RM/TEST_HDF5/d2021231'
             figpath    = '/home/soporte/Downloads/IMAGE'
             desc       = "Simulator Test"
             desc_data  = {
                         'Data': {
                             'dataPP_POW': ['Data/dataPP_POW/channel00','Data/dataPP_POW/channel01'],
                             'dataPP_DOP': ['Data/dataPP_DOP/channel00','Data/dataPP_DOP/channel01'],
                             'utctime':'Data/utctime'
                         },
                         'Metadata': {
                             'heightList' :'Metadata/heightList',
                             'flagDataAsBlock':'Metadata/flagDataAsBlock',
                             'channelList' :'Metadata/channelList',
                             'profileIndex' :'Metadata/profileIndex'
                         }
                     }
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
                                                         path=path,
                                                         startDate="2021/01/01",   #"2020/01/01",#today,
                                                         endDate= "2021/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=0,
                                                         description= json.dumps(desc_data))#1
             procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')#PulsepairPowerPlot
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
             opObj11 = procUnitConfObjA.addOperation(name='GenericRTIPlot',optype='external')
             opObj11.addParameter(name='attr_data', value='dataPP_POW')
             opObj11.addParameter(name='colormap', value='jet')
             opObj11.addParameter(name='xmin', value=tmmin)
             opObj11.addParameter(name='xmax', value=tmmax)
             opObj11.addParameter(name='zmin', value=dBmin)
             opObj11.addParameter(name='zmax', value=dBmax)
             opObj11.addParameter(name='save', value=figpath)
             opObj11.addParameter(name='showprofile', value=0)
             opObj11.addParameter(name='save_period', value=10)
             controllerObj.start()

schainpy/scripts/test_sim00011b.py +7 -4

             import os,sys,json
             import datetime
             import time
             from schainpy.controller import Project
             '''
             NOTA:
             Este script de prueba.
             - Unidad del lectura 'HDFReader'.
             - Unidad de procesamiento ParametersProc
             - Operacion SpectralMomentsPlot
             '''
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
             dBmin = '1'
             dBmax = '65'
             xmin = '0'
             xmax ='24'
-            tmmin = 16.2
+            #tmmin = 16.2
-            tmmax = 16.25
+            #tmmax = 16.25
+            tmmin =15
+            tmmax =15.5
             ymin = '0'
             ymax = '600'
             #######################################################################
             #######################################################################
             #######################################################################
-            path       = '/DATA_RM/TEST_HDF5_SPEC'
+            #path       = '/DATA_RM/TEST_HDF5_SPEC'
-            figpath    = '/home/soporte/Downloads/IMAGE'
+            path       = '/DATA_RM/TEST_HDF5_SPEC_23/6v/'
+            figpath    = '/home/soporte/Downloads/23/6v'
             desc       = "Simulator Test"
             desc_data  =  {
                             'Data': {
                                 'data_pow': ['Data/data_pow/channel00','Data/data_pow/channel01'],
                                 'data_dop': ['Data/data_dop/channel00','Data/data_dop/channel01'],
                                 'utctime':'Data/utctime'
                             },
                             'Metadata': {
                                 'heightList':'Metadata/heightList',
                                 'nIncohInt' :'Metadata/nIncohInt',
                                 'nCohInt' :'Metadata/nCohInt',
                                 'nProfiles' :'Metadata/nProfiles',
                                 'channelList' :'Metadata/channelList',
                                 'utctimeInit' :'Metadata/utctimeInit'
                              }
                            }
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
                                                         path=path,
                                                         startDate="2021/01/01",   #"2020/01/01",#today,
                                                         endDate= "2021/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         description= json.dumps(desc_data))#1
             procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
             opObj11 = procUnitConfObjA.addOperation(name='PowerPlot',optype='external')
             opObj11.addParameter(name='xmin', value=tmmin)
             opObj11.addParameter(name='xmax', value=tmmax)
             opObj11.addParameter(name='zmin', value=dBmin)
             opObj11.addParameter(name='zmax', value=dBmax)
             opObj11.addParameter(name='save', value=figpath)
             opObj11.addParameter(name='showprofile', value=0)
             opObj11.addParameter(name='save_period', value=10)
             controllerObj.start()

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