schain Commit - r1347:98dd11910247 · Jicamarca Repository

marzo update

avaldez -

r1347:98dd11910247

parent child

Context file:

r1347:98dd11910247

schainpy/scripts/test_sim00011.py created 644 +37 0

@@ -0,0 +1,37
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	#path = '/home/alex/Downloads/hdf5_testPP2'
	6	#path = '/home/alex/Downloads/hdf5_test'
	7	#path='/home/alex/Downloads/hdf5_wr'
	8	path='/home/developer/Downloads/HDF5_WR'
	9	figpath = path
	10	desc = "Simulator Test"
	11
	12	controllerObj = Project()
	13
	14	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	15
	16	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	17	path=path,
	18	startDate="2021/01/01", #"2020/01/01",#today,
	19	endDate= "2021/12/01", #"2020/12/30",#today,
	20	startTime='00:00:00',
	21	endTime='23:59:59',
	22	delay=0,
	23	#set=0,
	24	online=0,
	25	walk=0)#1
	26
	27	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	28	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	29	opObj11.addParameter(name='n', value='10', format='int')
	30
	31	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	32	#opObj11.addParameter(name='save', value=figpath)
	33	#opObj11.addParameter(name='save_period', value=1)
	34	#opObj11 = procUnitConfObjA.addOperation(name='PowerPlot', optype='other')#PulsepairPowerPlot
	35	#opObj11 = procUnitConfObjA.addOperation(name='PPSignalPlot', optype='other')
	36
	37	controllerObj.start()

schainpy/model/graphics/jroplot_parameters.py +212 -5

@@ -5,6 +5,7 import numpy
5	from schainpy.model.graphics.jroplot_base import Plot, plt	5	from schainpy.model.graphics.jroplot_base import Plot, plt
6	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot	6	from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot
7	from schainpy.utils import log	7	from schainpy.utils import log
		8	import wradlib as wrl
8		9
9	EARTH_RADIUS = 6.3710e3	10	EARTH_RADIUS = 6.3710e3
10		11
@@ -50,7 +51,7 class SnrPlot(RTIPlot):
50	def update(self, dataOut):	51	def update(self, dataOut):
51		52
52	data = {	53	data = {
53	'snr': 10*numpy.log10(dataOut.data_snr)	54	'snr': 10*numpy.log10(dataOut.data_snr)
54	}	55	}
55		56
56	return data, {}	57	return data, {}
@@ -66,7 +67,7 class DopplerPlot(RTIPlot):
66	def update(self, dataOut):	67	def update(self, dataOut):
67		68
68	data = {	69	data = {
69	'dop': 10*numpy.log10(dataOut.data_dop)	70	'dop': 10*numpy.log10(dataOut.data_dop)
70	}	71	}
71		72
72	return data, {}	73	return data, {}
@@ -82,7 +83,7 class PowerPlot(RTIPlot):
82	def update(self, dataOut):	83	def update(self, dataOut):
83		84
84	data = {	85	data = {
85	'pow': 10*numpy.log10(dataOut.data_pow)	86	'pow': 10*numpy.log10(dataOut.data_pow)
86	}	87	}
87		88
88	return data, {}	89	return data, {}
@@ -166,7 +167,7 class GenericRTIPlot(Plot):
166	self.nrows = self.data.shape(self.attr_data)[0]	167	self.nrows = self.data.shape(self.attr_data)[0]
167	self.nplots = self.nrows	168	self.nplots = self.nrows
168	self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})	169	self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
169		170
170	if not self.xlabel:	171	if not self.xlabel:
171	self.xlabel = 'Time'	172	self.xlabel = 'Time'
172		173
@@ -184,7 +185,7 class GenericRTIPlot(Plot):
184	meta = {}	185	meta = {}
185		186
186	return data, meta	187	return data, meta
187		188
188	def plot(self):	189	def plot(self):
189	# self.data.normalize_heights()	190	# self.data.normalize_heights()
190	self.x = self.data.times	191	self.x = self.data.times
@@ -356,3 +357,209 class PolarMapPlot(Plot):
356	self.titles = ['{} {}'.format(	357	self.titles = ['{} {}'.format(
357	self.data.parameters[x], title) for x in self.channels]	358	self.data.parameters[x], title) for x in self.channels]
358		359
		360	class WeatherPlot(Plot):
		361	CODE = 'weather'
		362	plot_name = 'weather'
		363	plot_type = 'ppistyle'
		364	buffering = False
		365
		366	def setup(self):
		367	self.ncols = 1
		368	self.nrows = 1
		369	self.nplots= 1
		370	self.ylabel= 'Range [Km]'
		371	self.titles= ['Weather']
		372	self.colorbar=False
		373	self.width =8
		374	self.height =8
		375	self.ini =0
		376	self.len_azi =0
		377	self.buffer_ini = None
		378	self.buffer_azi = None
		379	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
		380	self.flag =0
		381	self.indicador= 0
		382
		383	def update(self, dataOut):
		384
		385	data = {}
		386	meta = {}
		387	data['weather'] = 10numpy.log10(dataOut.data_360/(650*2))
		388	data['azi'] = dataOut.data_azi
		389
		390	return data, meta
		391
		392	def plot(self):
		393	stoprange = float(33*1.5)
		394	rangestep = float(0.15)
		395	r = numpy.arange(0, stoprange, rangestep)
		396	self.y = 2*r
		397	data = self.data[-1]
		398
		399	tmp_v = data['weather']
		400	tmp_z = data['azi']
		401	res = 1
		402	step = (360/(res*tmp_v.shape[0]))
		403	mode = 1
		404	if mode==0:
		405	print("self.ini",self.ini)
		406	val = numpy.mean(tmp_v[:,0])
		407	self.len_azi = len(tmp_z)
		408	ones = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
		409	self.buffer_ini = numpy.vstack((tmp_v,ones))
		410
		411	n = ((360/res)-len(tmp_z))
		412	start = tmp_z[-1]+res
		413	end = tmp_z[0]-res
		414	if start>end:
		415	end = end+360
		416	azi_zeros = numpy.linspace(start,end,int(n))
		417	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		418	self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
		419	self.ini = self.ini+1
		420
		421	if mode==1:
		422	print("self.ini",self.ini)
		423	if self.ini==0:
		424	res = 1
		425	step = (360/(res*tmp_v.shape[0]))
		426	val = numpy.mean(tmp_v[:,0])
		427	self.len_azi = len(tmp_z)
		428	self.buf_tmp = tmp_v
		429	ones = numpy.ones([(360-tmp_v.shape[0]),tmp_v.shape[1]])*val
		430	self.buffer_ini = numpy.vstack((tmp_v,ones))
		431
		432	n = ((360/res)-len(tmp_z))
		433	start = tmp_z[-1]+res
		434	end = tmp_z[0]-res
		435	if start>end:
		436	end =end+360
		437	azi_zeros = numpy.linspace(start,end,int(n))
		438	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		439	self.buf_azi = tmp_z
		440	self.buffer_ini_azi = numpy.hstack((tmp_z,azi_zeros))
		441	self.ini = self.ini+1
		442	elif 0<self.ini<step:
		443	'''
		444	if self.ini>31:
		445	start= tmp_z[0]
		446	end =tmp_z[-1]
		447	print("start","end",start,end)
		448	if self.ini==32:
		449	tmp_v=tmp_v+20
		450	if self.ini==33:
		451	tmp_v=tmp_v+10
		452	if self.ini==34:
		453	tmp_v=tmp_v+20
		454	if self.ini==35:
		455	tmp_v=tmp_v+20
		456	'''
		457	self.buf_tmp= numpy.vstack((self.buf_tmp,tmp_v))
		458	if self.buf_tmp.shape[0]==360:
		459	self.buffer_ini=self.buf_tmp
		460	else:
		461	val=30.0
		462	ones = numpy.ones([(360-self.buf_tmp.shape[0]),self.buf_tmp.shape[1]])*val
		463	self.buffer_ini = numpy.vstack((self.buf_tmp,ones))
		464
		465	self.buf_azi = numpy.hstack((self.buf_azi,tmp_z))
		466	n = ((360/res)-len(self.buf_azi))
		467	if n==0:
		468	self.buffer_ini_azi = self.buf_azi
		469	else:
		470	start = self.buf_azi[-1]+res
		471	end = self.buf_azi[0]-res
		472	if start>end:
		473	end =end+360
		474	azi_zeros = numpy.linspace(start,end,int(n))
		475	azi_zeros = numpy.where(azi_zeros>360,azi_zeros-360,azi_zeros)
		476	if tmp_z[0]<self.buf_azi[0] <tmp_z[-1]:
		477	self.indicador=1
		478	if self.indicador==1:
		479	azi_zeros = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
		480	# self.indicador = True
		481	#if self.indicador==True:
		482	# azi_zeros = numpy.ones(360-len(self.buf_azi))*(tmp_z[-1]+res)
		483
		484	#self.buf_azi = tmp_z
		485	self.buffer_ini_azi = numpy.hstack((self.buf_azi,azi_zeros))
		486
		487	if self.ini==step-1:
		488	start= tmp_z[0]
		489	end = tmp_z[-1]
		490	print("start","end",start,end)
		491	print(self.buffer_ini_azi[:80])
		492	self.ini = self.ini+1
		493
		494	else:
		495	step = (360/(res*tmp_v.shape[0]))
		496	tmp_v=tmp_v+5+(self.ini-step)*1
		497
		498	start= tmp_z[0]
		499	end = tmp_z[-1]
		500	print("start","end",start,end)
		501	print(self.buffer_ini_azi[:120])
		502
		503	if step>=2:
		504	if self.flag<step-1:
		505	limit_i=self.buf_azi[len(tmp_z)*(self.flag+1)]
		506	limit_s=self.buf_azi[len(tmp_z)*(self.flag+2)-1]
		507	print("flag",self.flag,limit_i,limit_s)
		508	if limit_i< tmp_z[-1]< limit_s:
		509	index_i=int(numpy.where(tmp_z<=self.buf_azi[len(tmp_z)*(self.flag+1)])[0][-1])
		510	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])
		511	print("tmp_r",tmp_r)
		512	index_f=(self.flag+1)*len(tmp_z)+tmp_r
		513
		514	if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f]):
		515	final = len(self.buf_azi[len(tmp_z)*(self.flag+1):index_f])
		516	else:
		517	final= len(tmp_z[index_i:])
		518	self.buf_azi[len(tmp_z)*(self.flag+1):index_f]=tmp_z[index_i:index_i+final]
		519	self.buf_tmp[len(tmp_z)*(self.flag+1):index_f,:]=tmp_v[index_i:index_i+final,:]
		520	if limit_i<tmp_z[0]<limit_s:
		521	index_f =int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
		522	n_p =index_f-len(tmp_z)*(self.flag+1)
		523	if n_p>0:
		524	self.buf_azi[len(tmp_z)(self.flag+1):index_f]=tmp_z[-1]numpy.ones(n_p)
		525	self.buf_tmp[len(tmp_z)(self.flag+1):index_f,:]=tmp_v[-1,:]numpy.ones([n_p,tmp_v.shape[1]])
		526
		527	'''
		528	if self.buf_azi[len(tmp_z)]<tmp_z[-1]<self.buf_azi[2*len(tmp_z)-1]:
		529	index_i= int(numpy.where(tmp_z <= self.buf_azi[len(tmp_z)])[0][-1])
		530	index_f= int(numpy.where(self.buf_azi>=tmp_z[-1])[0][0])
		531	#print("index",index_i,index_f)
		532	if len(tmp_z[index_i:])>len(self.buf_azi[len(tmp_z):index_f]):
		533	final = len(self.buf_azi[len(tmp_z):index_f])
		534	else:
		535	final = len(tmp_z[index_i:])
		536	self.buf_azi[len(tmp_z):index_f]=tmp_z[index_i:index_i+final]
		537	self.buf_tmp[len(tmp_z):index_f,:]=tmp_v[index_i:index_i+final,:]
		538	'''
		539	self.buf_tmp[len(tmp_z)(self.flag):len(tmp_z)(self.flag+1),:]=tmp_v
		540	self.buf_azi[len(tmp_z)(self.flag):len(tmp_z)(self.flag+1)] = tmp_z
		541	self.buffer_ini=self.buf_tmp
		542	self.buffer_ini_azi = self.buf_azi
		543	print("--------salida------------")
		544	start= tmp_z[0]
		545	end = tmp_z[-1]
		546	print("start","end",start,end)
		547	print(self.buffer_ini_azi[:120])
		548	self.ini= self.ini+1
		549	self.flag = self.flag +1
		550	if self.flag==step:
		551	self.flag=0
		552
		553	for i,ax in enumerate(self.axes):
		554	if ax.firsttime:
		555	plt.clf()
		556	cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=30, vmax=70)
		557	else:
		558	plt.clf()
		559	cgax, pm = wrl.vis.plot_ppi(self.buffer_ini,r=r,az=self.buffer_ini_azi,fig=self.figures[0], proj='cg', vmin=30, vmax=70)
		560	caax = cgax.parasites[0]
		561	paax = cgax.parasites[1]
		562	cbar = plt.gcf().colorbar(pm, pad=0.075)
		563	caax.set_xlabel('x_range [km]')
		564	caax.set_ylabel('y_range [km]')
		565	plt.text(1.0, 1.05, 'azimuth', transform=caax.transAxes, va='bottom',ha='right')

schainpy/model/graphics/jroplot_spectra.py +101 -14

@@ -46,9 +46,9 class SpectraPlot(Plot):
46	meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))	46	meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
47	if self.CODE == 'spc_moments':	47	if self.CODE == 'spc_moments':
48	data['moments'] = dataOut.moments	48	data['moments'] = dataOut.moments
49		49
50	return data, meta	50	return data, meta
51		51
52	def plot(self):	52	def plot(self):
53	if self.xaxis == "frequency":	53	if self.xaxis == "frequency":
54	x = self.data.xrange[0]	54	x = self.data.xrange[0]
@@ -146,8 +146,8 class CrossSpectraPlot(Plot):
146		146
147	data['cspc'] = numpy.array(tmp)	147	data['cspc'] = numpy.array(tmp)
148		148
149	return data, meta	149	return data, meta
150		150
151	def plot(self):	151	def plot(self):
152		152
153	if self.xaxis == "frequency":	153	if self.xaxis == "frequency":
@@ -159,7 +159,7 class CrossSpectraPlot(Plot):
159	else:	159	else:
160	x = self.data.xrange[2]	160	x = self.data.xrange[2]
161	self.xlabel = "Velocity (m/s)"	161	self.xlabel = "Velocity (m/s)"
162		162
163	self.titles = []	163	self.titles = []
164		164
165	y = self.data.yrange	165	y = self.data.yrange
@@ -183,13 +183,13 class CrossSpectraPlot(Plot):
183	ax.plt.set_array(coh.T.ravel())	183	ax.plt.set_array(coh.T.ravel())
184	self.titles.append(	184	self.titles.append(
185	'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))	185	'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
186		186
187	ax = self.axes[2 * n + 1]	187	ax = self.axes[2 * n + 1]
188	if ax.firsttime:	188	if ax.firsttime:
189	ax.plt = ax.pcolormesh(x, y, phase.T,	189	ax.plt = ax.pcolormesh(x, y, phase.T,
190	vmin=-180,	190	vmin=-180,
191	vmax=180,	191	vmax=180,
192	cmap=plt.get_cmap(self.colormap_phase)	192	cmap=plt.get_cmap(self.colormap_phase)
193	)	193	)
194	else:	194	else:
195	ax.plt.set_array(phase.T.ravel())	195	ax.plt.set_array(phase.T.ravel())
@@ -317,7 +317,7 class PhasePlot(CoherencePlot):
317		317
318	class NoisePlot(Plot):	318	class NoisePlot(Plot):
319	'''	319	'''
320	Plot for noise	320	Plot for noise
321	'''	321	'''
322		322
323	CODE = 'noise'	323	CODE = 'noise'
@@ -362,7 +362,7 class NoisePlot(Plot):
362	y = Y[ch]	362	y = Y[ch]
363	self.axes[0].lines[ch].set_data(x, y)	363	self.axes[0].lines[ch].set_data(x, y)
364		364
365		365
366	class PowerProfilePlot(Plot):	366	class PowerProfilePlot(Plot):
367		367
368	CODE = 'pow_profile'	368	CODE = 'pow_profile'
@@ -394,10 +394,10 class PowerProfilePlot(Plot):
394	self.y = y	394	self.y = y
395		395
396	x = self.data[-1][self.CODE]	396	x = self.data[-1][self.CODE]
397		397
398	if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9	398	if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
399	if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1	399	if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
400		400
401	if self.axes[0].firsttime:	401	if self.axes[0].firsttime:
402	for ch in self.data.channels:	402	for ch in self.data.channels:
403	self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))	403	self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
@@ -559,7 +559,7 class BeaconPhase(Plot):
559	server=None, folder=None, username=None, password=None,	559	server=None, folder=None, username=None, password=None,
560	ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):	560	ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
561		561
562	if dataOut.flagNoData:	562	if dataOut.flagNoData:
563	return dataOut	563	return dataOut
564		564
565	if not isTimeInHourRange(dataOut.datatime, xmin, xmax):	565	if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
@@ -699,4 +699,91 class BeaconPhase(Plot):
699	thisDatetime=thisDatetime,	699	thisDatetime=thisDatetime,
700	update_figfile=update_figfile)	700	update_figfile=update_figfile)
701		701
702	return dataOut No newline at end of file	702	return dataOut
		703
		704	class WeatherPlot(Plot):
		705	CODE = 'weather'
		706	plot_name = 'weather'
		707	plot_type = 'ppistyle'
		708	buffering = False
		709
		710	def setup(self):
		711	self.nplots = len(self.data.channels)
		712	self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
		713	self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
		714	self.height = 2.6 * self.nrows
		715	self.cb_label = 'dB'
		716	if self.showprofile:
		717	self.width = 4 * self.ncols
		718	else:
		719	self.width = 3.5 * self.ncols
		720	self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
		721	self.ylabel = 'Range [km]'
		722
		723	def update(self, dataOut):
		724
		725	data = {}
		726	meta = {}
		727	spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
		728	data['spc'] = spc
		729	data['rti'] = dataOut.getPower()
		730	data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
		731	meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
		732	if self.CODE == 'spc_moments':
		733	data['moments'] = dataOut.moments
		734
		735	return data, meta
		736
		737	def plot(self):
		738	if self.xaxis == "frequency":
		739	x = self.data.xrange[0]
		740	self.xlabel = "Frequency (kHz)"
		741	elif self.xaxis == "time":
		742	x = self.data.xrange[1]
		743	self.xlabel = "Time (ms)"
		744	else:
		745	x = self.data.xrange[2]
		746	self.xlabel = "Velocity (m/s)"
		747
		748	if self.CODE == 'spc_moments':
		749	x = self.data.xrange[2]
		750	self.xlabel = "Velocity (m/s)"
		751
		752	self.titles = []
		753
		754	y = self.data.yrange
		755	self.y = y
		756
		757	data = self.data[-1]
		758	z = data['spc']
		759
		760	for n, ax in enumerate(self.axes):
		761	noise = data['noise'][n]
		762	if self.CODE == 'spc_moments':
		763	mean = data['moments'][n, 2]
		764	if ax.firsttime:
		765	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
		766	self.xmin = self.xmin if self.xmin else -self.xmax
		767	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
		768	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
		769	ax.plt = ax.pcolormesh(x, y, z[n].T,
		770	vmin=self.zmin,
		771	vmax=self.zmax,
		772	cmap=plt.get_cmap(self.colormap)
		773	)
		774
		775	if self.showprofile:
		776	ax.plt_profile = self.pf_axes[n].plot(
		777	data['rti'][n], y)[0]
		778	ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
		779	color="k", linestyle="dashed", lw=1)[0]
		780	if self.CODE == 'spc_moments':
		781	ax.plt_mean = ax.plot(mean, y, color='k')[0]
		782	else:
		783	ax.plt.set_array(z[n].T.ravel())
		784	if self.showprofile:
		785	ax.plt_profile.set_data(data['rti'][n], y)
		786	ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
		787	if self.CODE == 'spc_moments':
		788	ax.plt_mean.set_data(mean, y)
		789	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))

schainpy/model/io/jroIO_base.py +81 -81

             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 return thisDate
             def parse_format(s, fmt):
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
                     d = DT_DIRECTIVES[fmt[x:x+2]]
                 def run(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def find_folders(self, path, startDate, endDate, folderfmt, last=False):
                     folders = [x for f in path.split(',')
                                for x in os.listdir(f) if os.path.isdir(os.path.join(f, x))]
                     folders.sort()
                     if last:
                         folders = [folders[-1]]
                     for folder in folders:
                         try:
                             dt = datetime.datetime.strptime(parse_format(folder, folderfmt), folderfmt).date()
                             if dt >= startDate and dt <= endDate:
                                 yield os.path.join(path, folder)
                             else:
                             log.log('Skiping folder {}'.format(folder), self.name)
                             continue
                     return
                 def find_files(self, folders, ext, filefmt, startDate=None, endDate=None,
                                expLabel='', last=False):
                     for path in folders:
                         files = glob.glob1(path, '*{}'.format(ext))
                         files.sort()
                         if last:
                             if files:
                                 fo = files[-1]
                                 try:
                                     dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                     yield os.path.join(path, expLabel, fo)
                                 except Exception as e:
                                     pass
                                 return
                             else:
                                 return
                         for fo in files:
                             try:
                                 dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                 if dt >= startDate and dt <= endDate:
                                     yield os.path.join(path, expLabel, fo)
                                 else:
                                     log.log('Skiping file {}'.format(fo), self.name)
                             except Exception as e:
                                 log.log('Skiping file {}'.format(fo), self.name)
                                 continue
                 def searchFilesOffLine(self, path, startDate, endDate,
                                        expLabel, ext, walk,
                                        filefmt, folderfmt):
                     """Search files in offline mode for the given arguments
                             path, startDate, endDate, folderfmt)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel)
                 def searchFilesOnLine(self, path, startDate, endDate,
                                       expLabel, ext, walk,
                                       filefmt, folderfmt):
                     """Search for the last file of the last folder
                     Return:
                         generator with the full path of last filename
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt, last=True)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel, last=True)
                     while True:
                         if self.fp != None:
                             self.fp.close()
                         if self.online:
                             newFile = self.setNextFileOnline()
                         else:
                             newFile = self.setNextFileOffline()
                         if not(newFile):
                             if self.online:
                                 raise schainpy.admin.SchainError('Time to wait for new files reach')
                                     raise schainpy.admin.SchainWarning('No files found in the given path')
                                 else:
                                     raise schainpy.admin.SchainWarning('No more files to read')
                         if self.verifyFile(self.filename):
                             break
                     log.log('Opening file: %s' % self.filename, self.name)
                     self.readFirstHeader()
                         self.filename
                         self.fp
                         self.filesize
                     Return:
                         boolean
                     nextFile = True
                     nextDay = False
                     for nFiles in range(self.nFiles+1):
                         for nTries in range(self.nTries):
                             fullfilename, filename = self.checkForRealPath(nextFile, nextDay)
                             if fullfilename is not None:
                                 self.name)
                             time.sleep(self.delay)
                             nextFile = False
                             continue
                         if fullfilename is not None:
                             break
                         self.nTries = 1
                         nextFile = True
                         if nFiles == (self.nFiles - 1):
                             log.log('Trying with next day...', self.name)
                             nextDay = True
                             self.nTries = 3
                     if fullfilename:
                         self.fileSize = os.path.getsize(fullfilename)
                         self.flagNoMoreFiles = 0
                         self.fileIndex += 1
                         return 1
                     else:
                         return 0
                 def setNextFileOffline(self):
                     """Open the next file to be readed in offline mode"""
                     try:
                         filename = next(self.filenameList)
                         self.fileIndex +=1
                     except StopIteration:
                         self.flagNoMoreFiles = 1
                         return 0
                     self.filename = filename
                     self.fileSize = os.path.getsize(filename)
                     self.flagIsNewFile = 1
                     return 1
                 @staticmethod
                 def isDateTimeInRange(dt, startDate, endDate, startTime, endTime):
                     """Check if the given datetime is in range"""
                     if startDate <= dt.date() <= endDate:
                         if startTime <= dt.time() <= endTime:
                             return True
                     return False
                 def verifyFile(self, filename):
                     """Check for a valid file
                     Arguments:
                         filename -- full path filename
                     Return:
                         boolean
                     """
                     """Check if the next file to be readed exists"""
                     raise NotImplementedError
                 def readFirstHeader(self):
                     """Parse the file header"""
                     Return:
                         str -- fullpath of the file
                     """
                     if nextFile:
                         self.set += 1
                     if nextDay:
                         prefixFileList = ['d', 'D']
                     elif self.ext.lower() == ".pdata":  # spectra
                         prefixFileList = ['p', 'P']
                     # barrido por las combinaciones posibles
                     for prefixDir in prefixDirList:
                         thispath = self.path
                             if os.path.exists(fullfilename):
                                 return fullfilename, filename
                     return None, filename
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.__waitNewBlock():
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     except IOError:
                         log.error("File {} can't be opened".format(filename), self.name)
                         return False
                     if self.online and self.waitDataBlock(0):
                         pass
                     basicHeaderObj = BasicHeader(LOCALTIME)
                     systemHeaderObj = SystemHeader()
                     radarControllerHeaderObj = RadarControllerHeader()
                         dt2 = basicHeaderObj.datatime
                         if not self.isDateTimeInRange(dt1, self.startDate, self.endDate, self.startTime, self.endTime) and not \
                                 self.isDateTimeInRange(dt2, self.startDate, self.endDate, self.startTime, self.endTime):
                             flag = False
                     fp.close()
                     return flag
                     return dateList
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.server is not None:
                         if 'tcp://' in self.server:
                             address = server
                             for nTries in range(self.nTries):
                                 fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                     self.endDate, self.expLabel, self.ext, self.walk,
                                     self.filefmt, self.folderfmt)
                                 try:
                                     fullpath = next(fullpath)
                                 except:
                                     fullpath = None
                                 if fullpath:
                                     break
                                 log.warning(
                                     'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                         self.delay, self.path, nTries + 1),
                                     self.name)
                                 time.sleep(self.delay)
                             if not(fullpath):
                                 raise schainpy.admin.SchainError(
                                     'There isn\'t any valid file in {}'.format(self.path))
                             pathname, filename = os.path.split(fullpath)
                             self.year = int(filename[1:5])
                             self.doy = int(filename[5:8])
                             self.set = int(filename[8:11]) - 1
                         else:
                             log.log("Searching files in {}".format(self.path), self.name)
                             self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     return
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                     """
                     Arguments:
                         path        :
                         startDate   :
                         endDate     :
                         startTime   :
                         endTime     :
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getProcessFlags(self):
                     processFlags = 0
                     self.basicHeaderObj.size = self.basicHeaderSize  # bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond = (self.dataOut.utctime - utc) * 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     if self.dataOut.datatime.date() > self.fileDate:
                         setFile = 0
                         self.nTotalBlocks = 0
                     filen = '{}{:04d}{:03d}{:03d}{}'.format(
                             self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext)
                     filename = os.path.join(path, subfolder, filen)
                     self.ext = ext.lower()
                     self.path = path
                     if set is None:
                         self.setFile = -1
                     else:
                         self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock

schainpy/model/io/jroIO_param.py +63 -42

                 This unit reads HDF5 files created with `HDFWriter` operation contains
                 by default two groups Data and Metadata all variables would be saved as `dataOut`
                 attributes.
                 It is possible to read any HDF5 file by given the structure in the `description`
                 parameter, also you can add extra values to metadata with the parameter `extras`.
                     Dictionary with the description of the HDF5 file
                 extras : dict, optional
                     Dictionary with extra metadata to be be added to `dataOut`
                 Examples
                 --------
                 desc = {
                     'Data': {
                         'data_output': ['u', 'v', 'w'],
                 extras = {
                     'timeZone': 300
                 }
                 reader = project.addReadUnit(
                     name='HDFReader',
                     path='/path/to/files',
                     self.folderfmt = "*%Y%j"
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata()
                     self.__readData()
                     self.__setBlockList()
                     if 'type' in self.meta:
                         self.dataOut = eval(self.meta['type'])()
                     for attr in self.meta:
                         setattr(self.dataOut, attr, self.meta[attr])
                     self.blockIndex = 0
                     return
                 def __setBlockList(self):
                     meta = {}
+                    desc = {
+                        'Data': {
+                            'dataPP_POW': 'Data/dataPP_POW/table00',
+                            'utctime':'Data/utctime'
+                        },
+                        'Metadata': {
+                            'azimuth' :'Metadata/azimuth',
+                            'heightList' :'Metadata/heightList',
+                            'flagDataAsBlock':'Metadata/flagDataAsBlock'
+                        }
+                    }
+                    self.description = desc
                     if self.description:
                         for key, value in self.description['Metadata'].items():
-                            meta[key] = self.fp[value].value
+                            try:
+                                meta[key] = self.fp[value].value
+                            except:
+                                meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name].value
                     if self.extras:
                         for key, value in self.extras.items():
                 def __readData(self):
                     data = {}
                     if self.description:
                         for key, value in self.description['Data'].items():
                             if isinstance(value, str):
                                 if isinstance(self.fp[value], h5py.Dataset):
-                                    data[key] = self.fp[value].value
+                                    try:
+                                        data[key] = self.fp[value].value
+                                    except:
+                                        ndim= self.fp[value][()].ndim
+                                        if ndim==2:
+                                            data[key] = numpy.swapaxes(self.fp[value][()],0,1)
+                                        if ndim==1:
+                                            data[key] = self.fp[value][()]
                                 elif isinstance(self.fp[value], h5py.Group):
                                     array = []
                                     for ch in self.fp[value]:
                                 array = numpy.array(array)
                             else:
                                 log.warning('Unknown type: {}'.format(name))
                             if name in self.description:
                                 key = self.description[name]
                             else:
                     self.data = data
                     return
                 def getData(self):
                     for attr in self.data:
                 The HDF5 file contains by default two groups Data and Metadata where
                 you can save any `dataOut` attribute specified by `dataList` and `metadataList`
                 parameters, data attributes are normaly time dependent where the metadata
                 are not.
                 It is possible to customize the structure of the HDF5 file with the
                 optional description parameter see the examples.
                 Parameters:
                     If True the name of the files corresponds to the timestamp of the data
                 description : dict, optional
                     Dictionary with the desired description of the HDF5 file
                 Examples
                 --------
                 desc = {
                     'data_output': {'winds': ['z', 'w', 'v']},
                     'utctime': 'timestamps',
                         'heightList': 'heights'
                     }
                 }
                 writer = proc_unit.addOperation(name='HDFWriter')
                 writer.addParameter(name='path', value='/path/to/file')
                 writer.addParameter(name='blocksPerFile', value='32')
                 lastTime = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                             dsDict['dtype'] = dataAux.dtype
                         dsList.append(dsDict)
                     self.dsList = dsList
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     self.dataOut = dataOut
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description)
                     self.putData()
                     return
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                             return 'pair{:02d}'.format(x)
                         else:
                             return 'channel{:02d}'.format(x)
                 def writeMetadata(self, fp):
                     if self.description:
                     return
                 def writeData(self, fp):
                     if self.description:
                         if 'Data' in self.description:
                             grp = fp.create_group('Data')
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
                                 (self.blocksPerFile, ),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
                                     (self.blocksPerFile, ) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True

schainpy/model/proc/jroproc_parameters.py +138 0

@@ -109,6 +109,13 class ParametersProc(ProcessingUnit):
109	self.dataOut.flagNoData = False	109	self.dataOut.flagNoData = False
110	self.dataOut.utctimeInit = self.dataIn.utctime	110	self.dataOut.utctimeInit = self.dataIn.utctime
111	self.dataOut.paramInterval = self.dataIn.nProfilesself.dataIn.nCohIntself.dataIn.ippSeconds	111	self.dataOut.paramInterval = self.dataIn.nProfilesself.dataIn.nCohIntself.dataIn.ippSeconds
		112
		113	if hasattr(self.dataIn, 'flagDataAsBlock'):
		114	self.dataOut.flagDataAsBlock = self.dataIn.flagDataAsBlock
		115
		116	if hasattr(self.dataIn, 'profileIndex'):
		117	self.dataOut.profileIndex = self.dataIn.profileIndex
		118
112	if hasattr(self.dataIn, 'dataPP_POW'):	119	if hasattr(self.dataIn, 'dataPP_POW'):
113	self.dataOut.dataPP_POW = self.dataIn.dataPP_POW	120	self.dataOut.dataPP_POW = self.dataIn.dataPP_POW
114		121
@@ -3998,3 +4005,134 class SMOperations():
3998	# error[indInvalid1] = 13	4005	# error[indInvalid1] = 13
3999	#	4006	#
4000	# return heights, error	4007	# return heights, error
		4008
		4009	class Block360(Operation):
		4010	'''
		4011	'''
		4012	isConfig = False
		4013	__profIndex = 0
		4014	__initime = None
		4015	__lastdatatime = None
		4016	__buffer = None
		4017	__dataReady = False
		4018	n = None
		4019	__nch = 0
		4020	__nHeis = 0
		4021	index = 0
		4022
		4023	def __init__(self,**kwargs):
		4024	Operation.__init__(self,**kwargs)
		4025
		4026	def setup(self, dataOut, n = None):
		4027	'''
		4028	n= Numero de PRF's de entrada
		4029	'''
		4030	self.__initime = None
		4031	self.__lastdatatime = 0
		4032	self.__dataReady = False
		4033	self.__buffer = 0
		4034	self.__buffer_1D = 0
		4035	self.__profIndex = 0
		4036	self.index = 0
		4037
		4038
		4039	#print("ELVALOR DE n es:", n)
		4040	if n == None:
		4041	raise ValueError("n should be specified.")
		4042
		4043	if n != None:
		4044	if n<2:
		4045	raise ValueError("n should be greater than 2")
		4046
		4047	self.n = n
		4048	#print("nHeights")
		4049	self.__buffer = numpy.zeros(( n, dataOut.nHeights))
		4050	self.__buffer2= numpy.zeros(n)
		4051
		4052	def putData(self,data):
		4053	'''
		4054	Add a profile to he __buffer and increase in one the __profiel Index
		4055	'''
		4056	#print("line 4049",data.dataPP_POW.shape,data.dataPP_POW[:10])
		4057	#print("line 4049",data.azimuth.shape,data.azimuth)
		4058	self.__buffer[self.__profIndex,:]= data.dataPP_POW
		4059	#print("me casi",self.index,data.azimuth[self.index])
		4060	#print(self.__profIndex, self.index , data.azimuth[self.index] )
		4061	#print("magic",data.profileIndex)
		4062	#print(data.azimuth[self.index])
		4063	#print("index",self.index)
		4064
		4065	self.__buffer2[self.__profIndex] = data.azimuth[self.index]
		4066	#print("q pasa")
		4067	self.index+=1
		4068	#print("index",self.index,data.azimuth[:10])
		4069	self.__profIndex += 1
		4070	return #················· Remove DC···································
		4071
		4072	def pushData(self,data):
		4073	'''
		4074	Return the PULSEPAIR and the profiles used in the operation
		4075	Affected : self.__profileIndex
		4076	'''
		4077	#print("pushData")
		4078
		4079	data_360 = self.__buffer
		4080	data_p = self.__buffer2
		4081	n = self.__profIndex
		4082
		4083	self.__buffer = numpy.zeros(( self.n,330))
		4084	self.__buffer2 = numpy.zeros(self.n)
		4085	self.__profIndex = 0
		4086	#print("pushData")
		4087	return data_360,n,data_p
		4088
		4089
		4090	def byProfiles(self,dataOut):
		4091
		4092	self.__dataReady = False
		4093	data_360 = None
		4094	data_p = None
		4095	#print("dataOu",dataOut.dataPP_POW)
		4096	self.putData(data=dataOut)
		4097	#print("profIndex",self.__profIndex)
		4098	if self.__profIndex == self.n:
		4099	data_360,n,data_p = self.pushData(data=dataOut)
		4100	self.__dataReady = True
		4101
		4102	return data_360,data_p
		4103
		4104
		4105	def blockOp(self, dataOut, datatime= None):
		4106	if self.__initime == None:
		4107	self.__initime = datatime
		4108	data_360,data_p = self.byProfiles(dataOut)
		4109	self.__lastdatatime = datatime
		4110
		4111	if data_360 is None:
		4112	return None, None,None
		4113
		4114	avgdatatime = self.__initime
		4115	deltatime = datatime - self.__lastdatatime
		4116	self.__initime = datatime
		4117	#print(data_360.shape,avgdatatime,data_p.shape)
		4118	return data_360,avgdatatime,data_p
		4119
		4120	def run(self, dataOut,n = None,**kwargs):
		4121
		4122	if not self.isConfig:
		4123	self.setup(dataOut = dataOut, n = n , **kwargs)
		4124	self.index = 0
		4125	#print("comova",self.isConfig)
		4126	self.isConfig = True
		4127	if self.index==dataOut.azimuth.shape[0]:
		4128	self.index=0
		4129	data_360, avgdatatime,data_p = self.blockOp(dataOut, dataOut.utctime)
		4130	dataOut.flagNoData = True
		4131
		4132	if self.__dataReady:
		4133	dataOut.data_360 = data_360 # S
		4134	dataOut.data_azi = data_p
		4135	#print("jroproc_parameters",data_p[0],data_p[-1])#,data_360.shape,avgdatatime)
		4136	dataOut.utctime = avgdatatime
		4137	dataOut.flagNoData = False
		4138	return dataOut

schainpy/model/proc/jroproc_voltage.py +19 -16

                     return dataOut
-            class PulsePairVoltage(Operation):
+            class PulsePair(Operation):
                 '''
                 Function PulsePair(Signal Power, Velocity)
                 The real component of Lag[0] provides Intensity Information
                 lambda_        = 0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                 def setup(self, dataOut, n = None, removeDC=False):
                     '''
                     n= Numero de PRF's de entrada
                     '''
+                    print("[INICIO]-setup  del METODO PULSE PAIR")
                     self.__initime        = None
                     self.__lastdatatime   = 0
                     self.__dataReady      = False
                     self.__buffer         = 0
                     self.__profIndex      = 0
                     self.noise            = None
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
                     self.removeDC         = removeDC
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
-                    #----------------- Remove DC-----------------------------------
+                    #················· Remove DC···································
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                         dc= numpy.tile(tmp,[1,self.__nProf,1])
                         self.__buffer = self.__buffer -  dc
-                    #------------------Calculo de Potencia ------------------------
+                    #··················Calculo de Potencia ························
                     pair0       = self.__buffer*numpy.conj(self.__buffer)
                     pair0       = pair0.real
                     lag_0       = numpy.sum(pair0,1)
-                    #------------------Calculo de Ruido x canal--------------------
+                    #··················Calculo de Ruido x canal····················
                     self.noise  = numpy.zeros(self.__nch)
                     for i in range(self.__nch):
                         daux         = numpy.sort(pair0[i,:,:],axis= None)
                     self.noise       = numpy.tile(self.noise,[1,self.__nHeis])
                     noise_buffer     = self.noise.reshape(self.__nch,1,self.__nHeis)
                     noise_buffer     = numpy.tile(noise_buffer,[1,self.__nProf,1])
-                    #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
+                    #·················· Potencia recibida= P , Potencia senal = S , Ruido= N··
-                    #------------------   P= S+N  ,P=lag_0/N ---------------------------------
+                    #··················   P= S+N  ,P=lag_0/N ·································
-                    #-------------------- Power --------------------------------------------------
+                    #···················· Power ··················································
                     data_power       = lag_0/(self.n*self.nCohInt)
-                    #------------------  Senal  ---------------------------------------------------
+                    #------------------  Senal  ···················································
                     data_intensity   = pair0 - noise_buffer
                     data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
                     #data_intensity   = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
                             if data_intensity[i][j]  < 0:
                                 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
-                    #----------------- Calculo de Frecuencia y Velocidad doppler--------
+                    #················· Calculo de Frecuencia y Velocidad doppler········
                     pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
                     lag_1            = numpy.sum(pair1,1)
                     data_freq        = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
                     data_velocity    = (self.lambda_/2.0)*data_freq
-                    #---------------- Potencia promedio estimada de la Senal-----------
+                    #················ Potencia promedio estimada de la Senal···········
                     lag_0            = lag_0/self.n
                     S                = lag_0-self.noise
-                    #---------------- Frecuencia Doppler promedio ---------------------
+                    #················ Frecuencia Doppler promedio ·····················
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
-                    #---------------- Calculo del SNR----------------------------------
+                    #················ Calculo del SNR··································
                     data_snrPP       = S/self.noise
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_snrPP[i][j]  < 1.e-20:
                                 data_snrPP[i][j] = 1.e-20
-                    #----------------- Calculo del ancho espectral ----------------------
+                    #················· Calculo del ancho espectral ······················
                     L                = S/R1
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)
                     return data_power, data_intensity, data_velocity, data_snrPP, data_specwidth, avgdatatime
-                def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
+                def run(self, dataOut,n = None,removeDC= False,**kwargs):
                     if not self.isConfig:
-                        self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
+                        self.setup( dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
                     data_power, data_intensity, data_velocity,data_snrPP,data_specwidth, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
                     dataOut.flagNoData                         = True
                         dataOut.dataPP_SNR      = data_snrPP
                         dataOut.dataPP_WIDTH    = data_specwidth
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
+                        dataOut.nProfiles       = int(dataOut.nProfiles/n)
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut
             # import collections
             # from scipy.stats import mode
             #

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