schain-jc Commit - r1187:66a3db7e736d

New plotting architecture with buffering/throttle capabilities

Juan C. Espinoza -

r1187:66a3db7e736d

parent child

Context file:

r1187:66a3db7e736d

Collapse all files

schainpy/model/graphics/jroplot_base.py created 644 +803 0

This diff has been collapsed as it changes many lines, (803 lines changed) Show them Hide them
	@@ -0,0 +1,803
		1
		2	import os
		3	import sys
		4	import zmq
		5	import time
		6	import datetime
		7	from functools import wraps
		8	import numpy
		9	import matplotlib
		10
		11	if 'BACKEND' in os.environ:
		12	matplotlib.use(os.environ['BACKEND'])
		13	elif 'linux' in sys.platform:
		14	matplotlib.use("TkAgg")
		15	elif 'darwin' in sys.platform:
		16	matplotlib.use('TkAgg')
		17	else:
		18	from schainpy.utils import log
		19	log.warning('Using default Backend="Agg"', 'INFO')
		20	matplotlib.use('Agg')
		21
		22	import matplotlib.pyplot as plt
		23	from matplotlib.patches import Polygon
		24	from mpl_toolkits.axes_grid1 import make_axes_locatable
		25	from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
		26
		27	from schainpy.model.data.jrodata import PlotterData
		28	from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
		29	from schainpy.utils import log
		30
		31	jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
		32	blu_values = matplotlib.pyplot.get_cmap(
		33	'seismic_r', 20)(numpy.arange(20))[10:15]
		34	ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
		35	'jro', numpy.vstack((blu_values, jet_values)))
		36	matplotlib.pyplot.register_cmap(cmap=ncmap)
		37
		38	CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
		39	'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
		40
		41	EARTH_RADIUS = 6.3710e3
		42
		43
		44	def ll2xy(lat1, lon1, lat2, lon2):
		45
		46	p = 0.017453292519943295
		47	a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
		48	numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
		49	r = 12742 * numpy.arcsin(numpy.sqrt(a))
		50	theta = numpy.arctan2(numpy.sin((lon2-lon1)p)numpy.cos(lat2p), numpy.cos(lat1p)
		51	* numpy.sin(lat2p)-numpy.sin(lat1p)numpy.cos(lat2p)numpy.cos((lon2-lon1)p))
		52	theta = -theta + numpy.pi/2
		53	return rnumpy.cos(theta), rnumpy.sin(theta)
		54
		55
		56	def km2deg(km):
		57	'''
		58	Convert distance in km to degrees
		59	'''
		60
		61	return numpy.rad2deg(km/EARTH_RADIUS)
		62
		63
		64	def figpause(interval):
		65	backend = plt.rcParams['backend']
		66	if backend in matplotlib.rcsetup.interactive_bk:
		67	figManager = matplotlib._pylab_helpers.Gcf.get_active()
		68	if figManager is not None:
		69	canvas = figManager.canvas
		70	if canvas.figure.stale:
		71	canvas.draw()
		72	try:
		73	canvas.start_event_loop(interval)
		74	except:
		75	pass
		76	return
		77
		78
		79	def popup(message):
		80	'''
		81	'''
		82
		83	fig = plt.figure(figsize=(12, 8), facecolor='r')
		84	text = '\n'.join([s.strip() for s in message.split(':')])
		85	fig.text(0.01, 0.5, text, ha='left', va='center',
		86	size='20', weight='heavy', color='w')
		87	fig.show()
		88	figpause(1000)
		89
		90
		91	class Throttle(object):
		92	'''
		93	Decorator that prevents a function from being called more than once every
		94	time period.
		95	To create a function that cannot be called more than once a minute, but
		96	will sleep until it can be called:
		97	@Throttle(minutes=1)
		98	def foo():
		99	pass
		100
		101	for i in range(10):
		102	foo()
		103	print "This function has run %s times." % i
		104	'''
		105
		106	def __init__(self, seconds=0, minutes=0, hours=0):
		107	self.throttle_period = datetime.timedelta(
		108	seconds=seconds, minutes=minutes, hours=hours
		109	)
		110
		111	self.time_of_last_call = datetime.datetime.min
		112
		113	def __call__(self, fn):
		114	@wraps(fn)
		115	def wrapper(args, *kwargs):
		116	coerce = kwargs.pop('coerce', None)
		117	if coerce:
		118	self.time_of_last_call = datetime.datetime.now()
		119	return fn(args, *kwargs)
		120	else:
		121	now = datetime.datetime.now()
		122	time_since_last_call = now - self.time_of_last_call
		123	time_left = self.throttle_period - time_since_last_call
		124
		125	if time_left > datetime.timedelta(seconds=0):
		126	return
		127
		128	self.time_of_last_call = datetime.datetime.now()
		129	return fn(args, *kwargs)
		130
		131	return wrapper
		132
		133	def apply_throttle(value):
		134
		135	@Throttle(seconds=value)
		136	def fnThrottled(fn):
		137	fn()
		138
		139	return fnThrottled
		140
		141	@MPDecorator
		142	class Plotter(ProcessingUnit):
		143	'''
		144	Proccessing unit to handle plot operations
		145	'''
		146
		147	def __init__(self):
		148
		149	ProcessingUnit.__init__(self)
		150
		151	def setup(self, **kwargs):
		152
		153	self.connections = 0
		154	self.web_address = kwargs.get('web_server', False)
		155	self.realtime = kwargs.get('realtime', False)
		156	self.localtime = kwargs.get('localtime', True)
		157	self.buffering = kwargs.get('buffering', True)
		158	self.throttle = kwargs.get('throttle', 2)
		159	self.exp_code = kwargs.get('exp_code', None)
		160	self.set_ready = apply_throttle(self.throttle)
		161	self.dates = []
		162	self.data = PlotterData(
		163	self.plots, self.throttle, self.exp_code, self.buffering)
		164	self.isConfig = True
		165
		166	def ready(self):
		167	'''
		168	Set dataOut ready
		169	'''
		170
		171	self.data.ready = True
		172	self.dataOut.data_plt = self.data
		173
		174	def run(self, realtime=True, localtime=True, buffering=True,
		175	throttle=2, exp_code=None, web_server=None):
		176
		177	if not self.isConfig:
		178	self.setup(realtime=realtime, localtime=localtime,
		179	buffering=buffering, throttle=throttle, exp_code=exp_code,
		180	web_server=web_server)
		181
		182	if self.web_address:
		183	log.success(
		184	'Sending to web: {}'.format(self.web_address),
		185	self.name
		186	)
		187	self.context = zmq.Context()
		188	self.sender_web = self.context.socket(zmq.REQ)
		189	self.sender_web.connect(self.web_address)
		190	self.poll = zmq.Poller()
		191	self.poll.register(self.sender_web, zmq.POLLIN)
		192	time.sleep(1)
		193
		194	# t = Thread(target=self.event_monitor, args=(monitor,))
		195	# t.start()
		196
		197	self.dataOut = self.dataIn
		198	self.data.ready = False
		199
		200	if self.dataOut.flagNoData:
		201	coerce = True
		202	else:
		203	coerce = False
		204
		205	if self.dataOut.type == 'Parameters':
		206	tm = self.dataOut.utctimeInit
		207	else:
		208	tm = self.dataOut.utctime
		209	if self.dataOut.useLocalTime:
		210	if not self.localtime:
		211	tm += time.timezone
		212	dt = datetime.datetime.fromtimestamp(tm).date()
		213	else:
		214	if self.localtime:
		215	tm -= time.timezone
		216	dt = datetime.datetime.utcfromtimestamp(tm).date()
		217	if dt not in self.dates:
		218	if self.data:
		219	self.ready()
		220	self.data.setup()
		221	self.dates.append(dt)
		222
		223	self.data.update(self.dataOut, tm)
		224
		225	if False: # TODO check when publishers ends
		226	self.connections -= 1
		227	if self.connections == 0 and dt in self.dates:
		228	self.data.ended = True
		229	self.ready()
		230	time.sleep(1)
		231	else:
		232	if self.realtime:
		233	self.ready()
		234	if self.web_address:
		235	retries = 5
		236	while True:
		237	self.sender_web.send(self.data.jsonify())
		238	socks = dict(self.poll.poll(5000))
		239	if socks.get(self.sender_web) == zmq.POLLIN:
		240	reply = self.sender_web.recv_string()
		241	if reply == 'ok':
		242	log.log("Response from server ok", self.name)
		243	break
		244	else:
		245	log.warning(
		246	"Malformed reply from server: {}".format(reply), self.name)
		247
		248	else:
		249	log.warning(
		250	"No response from server, retrying...", self.name)
		251	self.sender_web.setsockopt(zmq.LINGER, 0)
		252	self.sender_web.close()
		253	self.poll.unregister(self.sender_web)
		254	retries -= 1
		255	if retries == 0:
		256	log.error(
		257	"Server seems to be offline, abandoning", self.name)
		258	self.sender_web = self.context.socket(zmq.REQ)
		259	self.sender_web.connect(self.web_address)
		260	self.poll.register(self.sender_web, zmq.POLLIN)
		261	time.sleep(1)
		262	break
		263	self.sender_web = self.context.socket(zmq.REQ)
		264	self.sender_web.connect(self.web_address)
		265	self.poll.register(self.sender_web, zmq.POLLIN)
		266	time.sleep(1)
		267	else:
		268	self.set_ready(self.ready, coerce=coerce)
		269
		270	return
		271
		272	def close(self):
		273	pass
		274
		275
		276	@MPDecorator
		277	class Plot(Operation):
		278	'''
		279	Base class for Schain plotting operations
		280	'''
		281
		282	CODE = 'Figure'
		283	colormap = 'jro'
		284	bgcolor = 'white'
		285	__missing = 1E30
		286
		287	__attrs__ = ['show', 'save', 'xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax',
		288	'zlimits', 'xlabel', 'ylabel', 'xaxis', 'cb_label', 'title',
		289	'colorbar', 'bgcolor', 'width', 'height', 'localtime', 'oneFigure',
		290	'showprofile', 'decimation', 'pause']
		291
		292	def __init__(self):
		293
		294	Operation.__init__(self)
		295	self.isConfig = False
		296	self.isPlotConfig = False
		297
		298	def __fmtTime(self, x, pos):
		299	'''
		300	'''
		301
		302	return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
		303
		304	def __setup(self, **kwargs):
		305	'''
		306	Initialize variables
		307	'''
		308
		309	self.figures = []
		310	self.axes = []
		311	self.cb_axes = []
		312	self.localtime = kwargs.pop('localtime', True)
		313	self.show = kwargs.get('show', True)
		314	self.save = kwargs.get('save', False)
		315	self.ftp = kwargs.get('ftp', False)
		316	self.colormap = kwargs.get('colormap', self.colormap)
		317	self.colormap_coh = kwargs.get('colormap_coh', 'jet')
		318	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
		319	self.colormaps = kwargs.get('colormaps', None)
		320	self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
		321	self.showprofile = kwargs.get('showprofile', False)
		322	self.title = kwargs.get('wintitle', self.CODE.upper())
		323	self.cb_label = kwargs.get('cb_label', None)
		324	self.cb_labels = kwargs.get('cb_labels', None)
		325	self.labels = kwargs.get('labels', None)
		326	self.xaxis = kwargs.get('xaxis', 'frequency')
		327	self.zmin = kwargs.get('zmin', None)
		328	self.zmax = kwargs.get('zmax', None)
		329	self.zlimits = kwargs.get('zlimits', None)
		330	self.xmin = kwargs.get('xmin', None)
		331	self.xmax = kwargs.get('xmax', None)
		332	self.xrange = kwargs.get('xrange', 12)
		333	self.xscale = kwargs.get('xscale', None)
		334	self.ymin = kwargs.get('ymin', None)
		335	self.ymax = kwargs.get('ymax', None)
		336	self.yscale = kwargs.get('yscale', None)
		337	self.xlabel = kwargs.get('xlabel', None)
		338	self.decimation = kwargs.get('decimation', None)
		339	self.showSNR = kwargs.get('showSNR', False)
		340	self.oneFigure = kwargs.get('oneFigure', True)
		341	self.width = kwargs.get('width', None)
		342	self.height = kwargs.get('height', None)
		343	self.colorbar = kwargs.get('colorbar', True)
		344	self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
		345	self.channels = kwargs.get('channels', None)
		346	self.titles = kwargs.get('titles', [])
		347	self.polar = False
		348	self.grid = kwargs.get('grid', False)
		349	self.pause = kwargs.get('pause', False)
		350	self.save_labels = kwargs.get('save_labels', None)
		351	self.realtime = kwargs.get('realtime', True)
		352	self.buffering = kwargs.get('buffering', True)
		353	self.throttle = kwargs.get('throttle', 2)
		354	self.exp_code = kwargs.get('exp_code', None)
		355	self.__throttle_plot = apply_throttle(self.throttle)
		356	self.data = PlotterData(
		357	self.CODE, self.throttle, self.exp_code, self.buffering)
		358
		359	def __setup_plot(self):
		360	'''
		361	Common setup for all figures, here figures and axes are created
		362	'''
		363
		364	self.setup()
		365
		366	self.time_label = 'LT' if self.localtime else 'UTC'
		367	if self.data.localtime:
		368	self.getDateTime = datetime.datetime.fromtimestamp
		369	else:
		370	self.getDateTime = datetime.datetime.utcfromtimestamp
		371
		372	if self.width is None:
		373	self.width = 8
		374
		375	self.figures = []
		376	self.axes = []
		377	self.cb_axes = []
		378	self.pf_axes = []
		379	self.cmaps = []
		380
		381	size = '15%' if self.ncols == 1 else '30%'
		382	pad = '4%' if self.ncols == 1 else '8%'
		383
		384	if self.oneFigure:
		385	if self.height is None:
		386	self.height = 1.4 * self.nrows + 1
		387	fig = plt.figure(figsize=(self.width, self.height),
		388	edgecolor='k',
		389	facecolor='w')
		390	self.figures.append(fig)
		391	for n in range(self.nplots):
		392	ax = fig.add_subplot(self.nrows, self.ncols,
		393	n + 1, polar=self.polar)
		394	ax.tick_params(labelsize=8)
		395	ax.firsttime = True
		396	ax.index = 0
		397	ax.press = None
		398	self.axes.append(ax)
		399	if self.showprofile:
		400	cax = self.__add_axes(ax, size=size, pad=pad)
		401	cax.tick_params(labelsize=8)
		402	self.pf_axes.append(cax)
		403	else:
		404	if self.height is None:
		405	self.height = 3
		406	for n in range(self.nplots):
		407	fig = plt.figure(figsize=(self.width, self.height),
		408	edgecolor='k',
		409	facecolor='w')
		410	ax = fig.add_subplot(1, 1, 1, polar=self.polar)
		411	ax.tick_params(labelsize=8)
		412	ax.firsttime = True
		413	ax.index = 0
		414	ax.press = None
		415	self.figures.append(fig)
		416	self.axes.append(ax)
		417	if self.showprofile:
		418	cax = self.__add_axes(ax, size=size, pad=pad)
		419	cax.tick_params(labelsize=8)
		420	self.pf_axes.append(cax)
		421
		422	for n in range(self.nrows):
		423	if self.colormaps is not None:
		424	cmap = plt.get_cmap(self.colormaps[n])
		425	else:
		426	cmap = plt.get_cmap(self.colormap)
		427	cmap.set_bad(self.bgcolor, 1.)
		428	self.cmaps.append(cmap)
		429
		430	for fig in self.figures:
		431	fig.canvas.mpl_connect('key_press_event', self.OnKeyPress)
		432	fig.canvas.mpl_connect('scroll_event', self.OnBtnScroll)
		433	fig.canvas.mpl_connect('button_press_event', self.onBtnPress)
		434	fig.canvas.mpl_connect('motion_notify_event', self.onMotion)
		435	fig.canvas.mpl_connect('button_release_event', self.onBtnRelease)
		436	if self.show:
		437	fig.show()
		438
		439	def OnKeyPress(self, event):
		440	'''
		441	Event for pressing keys (up, down) change colormap
		442	'''
		443	ax = event.inaxes
		444	if ax in self.axes:
		445	if event.key == 'down':
		446	ax.index += 1
		447	elif event.key == 'up':
		448	ax.index -= 1
		449	if ax.index < 0:
		450	ax.index = len(CMAPS) - 1
		451	elif ax.index == len(CMAPS):
		452	ax.index = 0
		453	cmap = CMAPS[ax.index]
		454	ax.cbar.set_cmap(cmap)
		455	ax.cbar.draw_all()
		456	ax.plt.set_cmap(cmap)
		457	ax.cbar.patch.figure.canvas.draw()
		458	self.colormap = cmap.name
		459
		460	def OnBtnScroll(self, event):
		461	'''
		462	Event for scrolling, scale figure
		463	'''
		464	cb_ax = event.inaxes
		465	if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
		466	ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
		467	pt = ax.cbar.ax.bbox.get_points()[:, 1]
		468	nrm = ax.cbar.norm
		469	vmin, vmax, p0, p1, pS = (
		470	nrm.vmin, nrm.vmax, pt[0], pt[1], event.y)
		471	scale = 2 if event.step == 1 else 0.5
		472	point = vmin + (vmax - vmin) / (p1 - p0) * (pS - p0)
		473	ax.cbar.norm.vmin = point - scale * (point - vmin)
		474	ax.cbar.norm.vmax = point - scale * (point - vmax)
		475	ax.plt.set_norm(ax.cbar.norm)
		476	ax.cbar.draw_all()
		477	ax.cbar.patch.figure.canvas.draw()
		478
		479	def onBtnPress(self, event):
		480	'''
		481	Event for mouse button press
		482	'''
		483	cb_ax = event.inaxes
		484	if cb_ax is None:
		485	return
		486
		487	if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
		488	cb_ax.press = event.x, event.y
		489	else:
		490	cb_ax.press = None
		491
		492	def onMotion(self, event):
		493	'''
		494	Event for move inside colorbar
		495	'''
		496	cb_ax = event.inaxes
		497	if cb_ax is None:
		498	return
		499	if cb_ax not in [ax.cbar.ax for ax in self.axes if ax.cbar]:
		500	return
		501	if cb_ax.press is None:
		502	return
		503
		504	ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
		505	xprev, yprev = cb_ax.press
		506	dx = event.x - xprev
		507	dy = event.y - yprev
		508	cb_ax.press = event.x, event.y
		509	scale = ax.cbar.norm.vmax - ax.cbar.norm.vmin
		510	perc = 0.03
		511
		512	if event.button == 1:
		513	ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
		514	ax.cbar.norm.vmax -= (perc * scale) * numpy.sign(dy)
		515	elif event.button == 3:
		516	ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
		517	ax.cbar.norm.vmax += (perc * scale) * numpy.sign(dy)
		518
		519	ax.cbar.draw_all()
		520	ax.plt.set_norm(ax.cbar.norm)
		521	ax.cbar.patch.figure.canvas.draw()
		522
		523	def onBtnRelease(self, event):
		524	'''
		525	Event for mouse button release
		526	'''
		527	cb_ax = event.inaxes
		528	if cb_ax is not None:
		529	cb_ax.press = None
		530
		531	def __add_axes(self, ax, size='30%', pad='8%'):
		532	'''
		533	Add new axes to the given figure
		534	'''
		535	divider = make_axes_locatable(ax)
		536	nax = divider.new_horizontal(size=size, pad=pad)
		537	ax.figure.add_axes(nax)
		538	return nax
		539
		540	def setup(self):
		541	'''
		542	This method should be implemented in the child class, the following
		543	attributes should be set:
		544
		545	self.nrows: number of rows
		546	self.ncols: number of cols
		547	self.nplots: number of plots (channels or pairs)
		548	self.ylabel: label for Y axes
		549	self.titles: list of axes title
		550
		551	'''
		552	raise NotImplementedError
		553
		554	def fill_gaps(self, x_buffer, y_buffer, z_buffer):
		555	'''
		556	Create a masked array for missing data
		557	'''
		558	if x_buffer.shape[0] < 2:
		559	return x_buffer, y_buffer, z_buffer
		560
		561	deltas = x_buffer[1:] - x_buffer[0:-1]
		562	x_median = numpy.median(deltas)
		563
		564	index = numpy.where(deltas > 5 * x_median)
		565
		566	if len(index[0]) != 0:
		567	z_buffer[::, index[0], ::] = self.__missing
		568	z_buffer = numpy.ma.masked_inside(z_buffer,
		569	0.99 * self.__missing,
		570	1.01 * self.__missing)
		571
		572	return x_buffer, y_buffer, z_buffer
		573
		574	def decimate(self):
		575
		576	# dx = int(len(self.x)/self.__MAXNUMX) + 1
		577	dy = int(len(self.y) / self.decimation) + 1
		578
		579	# x = self.x[::dx]
		580	x = self.x
		581	y = self.y[::dy]
		582	z = self.z[::, ::, ::dy]
		583
		584	return x, y, z
		585
		586	def format(self):
		587	'''
		588	Set min and max values, labels, ticks and titles
		589	'''
		590
		591	if self.xmin is None:
		592	xmin = self.data.min_time
		593	else:
		594	if self.xaxis is 'time':
		595	dt = self.getDateTime(self.data.min_time)
		596	xmin = (dt.replace(hour=int(self.xmin), minute=0, second=0) -
		597	datetime.datetime(1970, 1, 1)).total_seconds()
		598	if self.data.localtime:
		599	xmin += time.timezone
		600	else:
		601	xmin = self.xmin
		602
		603	if self.xmax is None:
		604	xmax = xmin + self.xrange * 60 * 60
		605	else:
		606	if self.xaxis is 'time':
		607	dt = self.getDateTime(self.data.max_time)
		608	xmax = (dt.replace(hour=int(self.xmax), minute=59, second=59) -
		609	datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=1)).total_seconds()
		610	if self.data.localtime:
		611	xmax += time.timezone
		612	else:
		613	xmax = self.xmax
		614
		615	ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
		616	ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
		617
		618	Y = numpy.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000])
		619	i = 1 if numpy.where(
		620	abs(ymax-ymin) <= Y)[0][0] < 0 else numpy.where(abs(ymax-ymin) <= Y)[0][0]
		621	ystep = Y[i] / 10.
		622
		623	if self.xaxis is not 'time':
		624	X = numpy.array([1, 2, 5, 10, 20, 50, 100,
		625	200, 500, 1000, 2000, 5000])/2.
		626	i = 1 if numpy.where(
		627	abs(xmax-xmin) <= X)[0][0] < 0 else numpy.where(abs(xmax-xmin) <= X)[0][0]
		628	xstep = X[i] / 10.
		629
		630	for n, ax in enumerate(self.axes):
		631	if ax.firsttime:
		632	ax.set_facecolor(self.bgcolor)
		633	ax.yaxis.set_major_locator(MultipleLocator(ystep))
		634	if self.xscale:
		635	ax.xaxis.set_major_formatter(FuncFormatter(
		636	lambda x, pos: '{0:g}'.format(x*self.xscale)))
		637	if self.xscale:
		638	ax.yaxis.set_major_formatter(FuncFormatter(
		639	lambda x, pos: '{0:g}'.format(x*self.yscale)))
		640	if self.xaxis is 'time':
		641	ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
		642	ax.xaxis.set_major_locator(LinearLocator(9))
		643	else:
		644	ax.xaxis.set_major_locator(MultipleLocator(xstep))
		645	if self.xlabel is not None:
		646	ax.set_xlabel(self.xlabel)
		647	ax.set_ylabel(self.ylabel)
		648	ax.firsttime = False
		649	if self.showprofile:
		650	self.pf_axes[n].set_ylim(ymin, ymax)
		651	self.pf_axes[n].set_xlim(self.zmin, self.zmax)
		652	self.pf_axes[n].set_xlabel('dB')
		653	self.pf_axes[n].grid(b=True, axis='x')
		654	[tick.set_visible(False)
		655	for tick in self.pf_axes[n].get_yticklabels()]
		656	if self.colorbar:
		657	ax.cbar = plt.colorbar(
		658	ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
		659	ax.cbar.ax.tick_params(labelsize=8)
		660	ax.cbar.ax.press = None
		661	if self.cb_label:
		662	ax.cbar.set_label(self.cb_label, size=8)
		663	elif self.cb_labels:
		664	ax.cbar.set_label(self.cb_labels[n], size=8)
		665	else:
		666	ax.cbar = None
		667	if self.grid:
		668	ax.grid(True)
		669
		670	if not self.polar:
		671	ax.set_xlim(xmin, xmax)
		672	ax.set_ylim(ymin, ymax)
		673	ax.set_title('{} {} {}'.format(
		674	self.titles[n],
		675	self.getDateTime(self.data.max_time).strftime(
		676	'%Y-%m-%dT%H:%M:%S'),
		677	self.time_label),
		678	size=8)
		679	else:
		680	ax.set_title('{}'.format(self.titles[n]), size=8)
		681	ax.set_ylim(0, 90)
		682	ax.set_yticks(numpy.arange(0, 90, 20))
		683	ax.yaxis.labelpad = 40
		684
		685	def clear_figures(self):
		686	'''
		687	Reset axes for redraw plots
		688	'''
		689
		690	for ax in self.axes:
		691	ax.clear()
		692	ax.firsttime = True
		693	if ax.cbar:
		694	ax.cbar.remove()
		695
		696	def __plot(self):
		697	'''
		698	Main function to plot, format and save figures
		699	'''
		700
		701	#try:
		702	self.plot()
		703	self.format()
		704	#except Exception as e:
		705	# log.warning('{} Plot could not be updated... check data'.format(
		706	# self.CODE), self.name)
		707	# log.error(str(e), '')
		708	# return
		709
		710	for n, fig in enumerate(self.figures):
		711	if self.nrows == 0 or self.nplots == 0:
		712	log.warning('No data', self.name)
		713	fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
		714	fig.canvas.manager.set_window_title(self.CODE)
		715	continue
		716
		717	fig.tight_layout()
		718	fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
		719	self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
		720	fig.canvas.draw()
		721
		722	if self.save:
		723
		724	if self.save_labels:
		725	labels = self.save_labels
		726	else:
		727	labels = list(range(self.nrows))
		728
		729	if self.oneFigure:
		730	label = ''
		731	else:
		732	label = '-{}'.format(labels[n])
		733	figname = os.path.join(
		734	self.save,
		735	self.CODE,
		736	'{}{}_{}.png'.format(
		737	self.CODE,
		738	label,
		739	self.getDateTime(self.data.max_time).strftime(
		740	'%Y%m%d_%H%M%S'),
		741	)
		742	)
		743	log.log('Saving figure: {}'.format(figname), self.name)
		744	if not os.path.isdir(os.path.dirname(figname)):
		745	os.makedirs(os.path.dirname(figname))
		746	fig.savefig(figname)
		747
		748	def plot(self):
		749	'''
		750	Must be defined in the child class
		751	'''
		752	raise NotImplementedError
		753
		754	def run(self, dataOut, **kwargs):
		755
		756	if dataOut.flagNoData and not dataOut.error:
		757	return dataOut
		758
		759	if dataOut.error:
		760	coerce = True
		761	else:
		762	coerce = False
		763
		764	if self.isConfig is False:
		765	self.__setup(**kwargs)
		766	self.data.setup()
		767	self.isConfig = True
		768
		769	if dataOut.type == 'Parameters':
		770	tm = dataOut.utctimeInit
		771	else:
		772	tm = dataOut.utctime
		773
		774	if dataOut.useLocalTime:
		775	if not self.localtime:
		776	tm += time.timezone
		777	else:
		778	if self.localtime:
		779	tm -= time.timezone
		780
		781	if self.data and (tm - self.data.min_time) >= self.xrange6060:
		782	self.__plot()
		783	self.data.setup()
		784	self.clear_figures()
		785
		786	self.data.update(dataOut, tm)
		787
		788	if self.isPlotConfig is False:
		789	self.__setup_plot()
		790	self.isPlotConfig = True
		791
		792	if self.realtime:
		793	self.__plot()
		794	else:
		795	self.__throttle_plot(self.__plot, coerce=coerce)
		796
		797	figpause(0.001)
		798
		799	def close(self):
		800
		801	if self.data and self.pause:
		802	figpause(10)
		803

schainpy/CHANGELOG.md +7 0

             ## CHANGELOG:
+            ### 3.0
+            * Python 3.x compatible
+            * New architecture with multiprocessing and IPC communication
+            * Add @MPDecorator for multiprocessing Units and Operations
+            * Added new type of operation `external` for non-locking operations
+            * New plotting architecture with buffering/throttle capabilities to speed up plots
             ### 2.3
             * Added support for Madrigal formats (reading/writing).
             * Added support for reading BLTR parameters (*.sswma).
             * Added support for reading Julia format (*.dat).
             * Added high order function `MPProject` for multiprocessing scripts.
             * Added two new Processing Units `PublishData` and `ReceiverData` for receiving and sending dataOut through multiple ways (tcp, ipc, inproc).
             * Added a new graphics Processing Unit `PlotterReceiver`. It is decoupled from normal processing sequence with support for data generated by multiprocessing scripts.
             * Added support for sending realtime graphic to web server.
             * GUI command `schain` is now `schainGUI`.
             * Added a CLI tool named `schain`.
             	* Scripts templates can be now generated with `schain generate`.
             	* Now it is possible to search Processing Units and Operations with `schain search [module]` to get the right name and its allowed parameters.
             	* `schain xml` to run xml scripts.
             * Added suggestions when parameters are poorly written.
             * `Controller.start()` now runs in a different process than the process calling it.
             * Added `schainpy.utils.log` for log standarization.
             * Running script on online mode no longer ignores date and hour. Issue #1109.
             * Added support for receving voltage data directly from JARS (tcp, ipc).
             * Updated README for MAC OS GUI installation.
             * Setup now installs numpy.
             ### 2.2.6
             * Graphics generated by the GUI are now the same as generated by scripts. Issue #1074.
             * Added support for C extensions.
             * Function `hildebrand_sehkon` optimized with a C wrapper.
             * Numpy version updated.
             * Migration to GIT.
             ### 2.2.5:
             * splitProfiles and combineProfiles modules were added to VoltageProc and Signal Chain GUI.
             * nProfiles of USRP data (hdf5) is the number of profiles thera are in one second.
             * jroPlotter works directly with data objects instead of dictionaries
             * script "schain" was added to Signal Chain installer
             ### 2.2.4.1:
             * jroIO_usrp.py is update to read Sandra's data
             * decimation in Spectra and RTI plots is always enabled.
             * time* window option added to GUI
             ### 2.2.4:
             * jroproc_spectra_lags.py added to schainpy
             * Bug fixed in schainGUI: ProcUnit was created with the same id in some cases.
             * Bug fixed in jroHeaderIO: Header size validation.
             ### 2.2.3.1:
             * Filtering block by time has been added.
             * Bug fixed plotting RTI, CoherenceMap and others using xmin and xmax parameters. The first day worked
             properly but the next days did not.
             ### 2.2.3:
             * Bug fixed in GUI: Error getting(reading) Code value
             * Bug fixed in GUI: Flip option always needs channelList field
             * Bug fixed in jrodata: when one branch modified a value in "dataOut" (example: dataOut.code) this value
             was modified for every branch (because this was a reference). It was modified in data.copy()
             * Bug fixed in jroproc_voltage.profileSelector(): rangeList replaces to profileRangeList.
             ### 2.2.2:
             * VoltageProc: ProfileSelector, Reshape, Decoder with nTxs!=1 and getblock=True was tested
             * Rawdata and testRawdata.py added to Signal Chain project
             ### 2.2.1:
             * Bugs fixed in GUI
             * Views were improved in GUI
             * Support to MST* ISR experiments
             * Bug fixed getting noise using hyldebrant. (minimum number of points > 20%)
             * handleError added to jroplotter.py
             ### 2.2.0:
             * GUI: use of external plotter
             * Compatible with matplotlib 1.5.0
             ### 2.1.5:
             * serializer module added to Signal Chain
             * jroplotter.py added to Signal Chain
             ### 2.1.4.2:
             * A new Plotter Class was added
             * Project.start() does not accept filename as a parameter anymore
             ### 2.1.4.1:
             * Send notifications when an error different to ValueError is detected
             ### 2.1.4:
             * Sending error notifications to signal chain administrator
             * Login to email server added
             ### 2.1.3.3:
             * Colored Button Icons were added to GUI
             ### 2.1.3.2:
             * GUI: user interaction enhanced
             * controller_api.py: Safe access to ControllerThead
             ### 2.1.3.1:
             * GUI: every icon were resized
             * jroproc_voltage.py: Print a message when "Read from code" option is selected and the code is not defined inside data file
             ### 2.1.3:
             * jroplot_heispectra.py: SpectraHeisScope was not showing the right channels
             * jroproc_voltage.py: Bug fixed selecting profiles (self.nProfiles took a wrong value),
             					 Bug fixed selecting heights by block (selecting profiles instead heights)
             * jroproc_voltage.py: New feature added: decoding data by block using FFT.
             * jroIO_heispectra.py: Bug fixed in FitsReader. Using local Fits instance instead schainpy.mode.data.jrodata.Fits.
             * jroIO_heispectra.py: Channel index list does not exist.
             ### 2.1.2:
             * jroutils_ftp.py: Bug fixed, Any error sending file stopped the Server Thread
             				  Server thread opens and closes remote server each time file list is sent
             * jroplot_spectra.py: Noise path was not being created when noise data is saved.
             * jroIO_base.py: startTime can be greater than endTime. Example: SpreadF [18:00 *  07:00]

schainpy/admin.py +1 -1

             """
             The admin module contains all administrative classes relating to the schain python api.
             The main role of this module is to send some reports. It contains a
             notification class and a standard error handing class.
             $Id: admin.py 3966 2015-12-01 14:32:29Z miguel.urco $
             """
             import os
             import sys
             import time
             import traceback
             import smtplib
             if sys.version[0] == '3':
                 from configparser import ConfigParser
             else:
                 from ConfigParser import ConfigParser
             import io
             from threading import Thread
             from multiprocessing import Process
             from email.mime.text import MIMEText
             from email.mime.application import MIMEApplication
             from email.mime.multipart import MIMEMultipart
             import schainpy
             from schainpy.utils import log
-            from schainpy.model.graphics.jroplot_data import popup
+            from schainpy.model.graphics.jroplot_base import popup
             def get_path():
                 '''
                 Return schainpy path
                 '''
                 try:
                     root = __file__
                     if os.path.islink(root):
                         root = os.path.realpath(root)
                     return os.path.dirname(os.path.abspath(root))
                 except:
                     log.error('I am sorry, but something is wrong... __file__ not found')
             class Alarm(Process):
                 '''
                 modes:
 - All
 - Send email
 - Popup message
 - Sound alarm
 - Send to alarm system TODO
                 '''
                 def __init__(self, modes=[], **kwargs):
                     Process.__init__(self)
                     self.modes = modes
                     self.kwargs = kwargs
                 @staticmethod
                 def play_sound():
                     sound = os.path.join(get_path(), 'alarm1.oga')
                     if os.path.exists(sound):
                         for __ in range(2):
                             os.system('paplay {}'.format(sound))
                             time.sleep(0.5)
                     else:
                         log.warning('Unable to play alarm, sound file not found', 'ADMIN')
                 @staticmethod
                 def send_email(**kwargs):
                     notifier = SchainNotify()
                     print(kwargs)
                     notifier.notify(**kwargs)
                 @staticmethod
                 def show_popup(message):
                     if isinstance(message, list):
                         message = message[-1]
                     popup(message)
                 @staticmethod
                 def send_alarm():
                     pass
                 @staticmethod
                 def get_kwargs(kwargs, keys):
                     ret = {}
                     for key in keys:
                         ret[key] = kwargs[key]
                     return ret
                 def run(self):
                     tasks = {
 : self.send_email,
 : self.show_popup,
 : self.play_sound,
 : self.send_alarm,
                     }
                     tasks_args = {
 : ['email', 'message', 'subject', 'subtitle', 'filename'],
 : ['message'],
 : [],
 : [],
                     }
                     procs = []
                     for mode in self.modes:
                         if 0 in self.modes:
                             for x in tasks:
                                 t = Thread(target=tasks[x], kwargs=self.get_kwargs(self.kwargs, tasks_args[x]))
                                 t.start()
                                 procs.append(t)
                             break
                         else:
                             t = Thread(target=tasks[mode], kwargs=self.get_kwargs(self.kwargs, tasks_args[mode]))
                             t.start()
                             procs.append(t)
                     for t in procs:
                         t.join()
             class SchainConfigure():
                 __DEFAULT_ADMINISTRATOR_EMAIL = "juan.espinoza@jro.igp.gob.pe"
                 __DEFAULT_EMAIL_SERVER = "jro-zimbra.igp.gob.pe"
                 __DEFAULT_SENDER_EMAIL = "notifier-schain@jro.igp.gob.pe"
                 __DEFAULT_SENDER_PASS = ""
                 __SCHAIN_ADMINISTRATOR_EMAIL = "CONTACT"
                 __SCHAIN_EMAIL_SERVER = "MAILSERVER"
                 __SCHAIN_SENDER_EMAIL = "MAILSERVER_ACCOUNT"
                 __SCHAIN_SENDER_PASS = "MAILSERVER_PASSWORD"
                 def __init__(self, initFile = None):
                     # Set configuration file
                     if (initFile == None):
                         self.__confFilePath = "/etc/schain.conf"
                     else:
                         self.__confFilePath = initFile
                     # open configuration file
                     try:
                         self.__confFile = open(self.__confFilePath, "r")
                     except IOError:
                         # can't read from file - use all hard-coded values
                         self.__initFromHardCode()
                         return
                     # create Parser using standard module ConfigParser
                     self.__parser = ConfigParser()
                     # read conf file into a StringIO with "[madrigal]\n" section heading prepended
                     strConfFile = io.StringIO("[schain]\n" + self.__confFile.read())
                     # parse StringIO configuration file
                     self.__parser.readfp(strConfFile)
                     # read information from configuration file
                     self.__readConfFile()
                     # close conf file
                     self.__confFile.close()
                 def __initFromHardCode(self):
                     self.__sender_email = self.__DEFAULT_SENDER_EMAIL
                     self.__sender_pass = self.__DEFAULT_SENDER_PASS
                     self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
                     self.__email_server = self.__DEFAULT_EMAIL_SERVER
                 def __readConfFile(self):
                     """__readConfFile is a private helper function that reads information from the parsed config file.
                     Inputs: None
                     Returns: Void.
                     Affects: Initializes class member variables that are found in the config file.
                     Exceptions: MadrigalError thrown if any key not found.
                     """
                     # get the sender email
                     try:
                         self.__sender_email = self.__parser.get("schain", self.__SCHAIN_SENDER_EMAIL)
                     except:
                         self.__sender_email = self.__DEFAULT_SENDER_EMAIL
                     # get the sender password
                     try:
                         self.__sender_pass = self.__parser.get("schain", self.__SCHAIN_SENDER_PASS)
                     except:
                         self.__sender_pass = self.__DEFAULT_SENDER_PASS
                     # get the administrator email
                     try:
                         self.__admin_email = self.__parser.get("schain", self.__SCHAIN_ADMINISTRATOR_EMAIL)
                     except:
                         self.__admin_email = self.__DEFAULT_ADMINISTRATOR_EMAIL
                     # get the server email
                     try:
                         self.__email_server = self.__parser.get("schain", self.__SCHAIN_EMAIL_SERVER)
                     except:
                         self.__email_server = self.__DEFAULT_EMAIL_SERVER
                 def getEmailServer(self):
                     return self.__email_server
                 def getSenderEmail(self):
                     return self.__sender_email
                 def getSenderPass(self):
                     return self.__sender_pass
                 def getAdminEmail(self):
                     return self.__admin_email
             class SchainNotify:
                 """SchainNotify is an object used to send messages to an administrator about a Schain software.
                 This object provides functions needed to send messages to an administrator about a Schain , for now
                 only sendAlert, which sends an email to the site administrator found is ADMIN_EMAIL
                 Usage example:
                     import schainpy.admin
                     try:
                         adminObj =  schainpy.admin.SchainNotify()
                         adminObj.sendAlert('This is important!', 'Important Message')
                     except schainpy.admin.SchainError, e:
                         print e.getExceptionStr()
                 Non-standard Python modules used:
                 None
                 Exceptions thrown: None - Note that SchainNotify tries every trick it knows to avoid
                 throwing exceptions, since this is the class that will generally be called when there is a problem.
                 Change history:
                 Written by "Miguel Urco":mailto:miguel.urco@jro.igp.gob.pe  Dec. 1, 2015
                 """
                 #constants
                 def __init__(self):
                     """__init__ initializes SchainNotify by getting some basic information from SchainDB and SchainSite.
                     Note that SchainNotify tries every trick it knows to avoid throwing exceptions, since
                     this is the class that will generally be called when there is a problem.
                     Inputs: Existing SchainDB object, by default = None.
                     Returns: void
                     Affects: Initializes self.__binDir.
                     Exceptions: None.
                     """
                     # note that the main configuration file is unavailable
                     # the best that can be done is send an email to root using localhost mailserver
                     confObj = SchainConfigure()
                     self.__emailFromAddress = confObj.getSenderEmail()
                     self.__emailPass = confObj.getSenderPass()
                     self.__emailToAddress = confObj.getAdminEmail()
                     self.__emailServer  = confObj.getEmailServer()
                 def sendEmail(self, email_from, email_to, subject='Error running ...', message="", subtitle="", filename="", html_format=True):
                     if not email_to:
                         return 0
                     if not self.__emailServer:
                         return 0
                     log.success('Sending email to {}...'.format(email_to), 'System')
                     msg = MIMEMultipart()
                     msg['Subject'] = subject
                     msg['From'] = "(Python SChain API): " + email_from
                     msg['Reply-to'] = email_from
                     msg['To'] = email_to
                     # That is what u see if dont have an email reader:
                     msg.preamble = 'SChainPy'
                     if html_format:
                         message = "<h1> %s </h1>" %subject + "<h3>" + subtitle.replace("\n", "</h3><h3>\n") + "</h3>" + message.replace("\n", "<br>\n")
                         message = "<html>\n" + message + '</html>'
                         # This is the textual part:
                         part = MIMEText(message, "html")
                     else:
                         message = subject + "\n" + subtitle + "\n" + message
                         part = MIMEText(message)
                     msg.attach(part)
                     if filename and os.path.isfile(filename):
                         # This is the binary part(The Attachment):
                         part = MIMEApplication(open(filename,"rb").read())
                         part.add_header('Content-Disposition',
                                         'attachment',
                                         filename=os.path.basename(filename))
                         msg.attach(part)
                     # Create an instance in SMTP server
                     try:
                         smtp = smtplib.SMTP(self.__emailServer)
                     except:
                         log.error('Could not connect to server {}'.format(self.__emailServer), 'System')
                         return 0
                     # Start the server:
                 #         smtp.ehlo()
                     if self.__emailPass:
                         smtp.login(self.__emailFromAddress, self.__emailPass)
                     # Send the email
                     try:
                         smtp.sendmail(msg['From'], msg['To'], msg.as_string())
                     except:
                         log.error('Could not send the email to {}'.format(msg['To']), 'System')
                         smtp.quit()
                         return 0
                     smtp.quit()
                     log.success('Email sent ', 'System')
                     return 1
                 def sendAlert(self, message, subject = "", subtitle="", filename=""):
                     """sendAlert sends an email with the given message and optional title.
                     Inputs: message (string), and optional title (string)
                     Returns: void
                     Affects: none
                     Exceptions: None.
                     """
                     if not self.__emailToAddress:
                         return 0
                     print("***** Sending alert to %s *****" %self.__emailToAddress)
                     # set up message
                     sent=self.sendEmail(email_from=self.__emailFromAddress,
                                        email_to=self.__emailToAddress,
                                        subject=subject,
                                        message=message,
                                        subtitle=subtitle,
                                        filename=filename)
                     if not sent:
                         return 0
                     return 1
                 def notify(self, email, message, subject = "", subtitle="", filename=""):
                     """notify sends an email with the given message and title to email.
                     Inputs: email (string), message (string), and subject (string)
                     Returns: void
                     Affects: none
                     Exceptions: None.
                     """
                     if email is None:
                         email = self.__emailToAddress
                     self.sendEmail(
                         email_from=self.__emailFromAddress,
                         email_to=email,
                         subject=subject,
                         message=message,
                         subtitle=subtitle,
                         filename=filename
                         )
             class SchainError(Exception):
                 """SchainError is an exception class that is thrown for all known errors using Schain Py lib.
                 Usage example:
                     import sys, traceback
                     import schainpy.admin
                     try:
                         test = open('ImportantFile.txt', 'r')
                     except:
                         raise schainpy.admin.SchainError('ImportantFile.txt not opened!',
                                                             traceback.format_exception(sys.exc_info()[0],
                                                                                     sys.exc_info()[1],
                                                                                     sys.exc_info()[2]))
                 """
                 def __init__(self, strInterpretation, exceptionList=None):
                     """ __init__ gathers the interpretation string along with all information from sys.exc_info().
                     Inputs:
                             strIntepretation - A string representing the programmer's interpretation of
                             why the exception occurred
                             exceptionList - a list of strings completely describing the exception.
                             Generated by traceback.format_exception(sys.exc_info()[0],
                                                                     sys.exc_info()[1],
                                                                     sys.exc_info()[2])
                     Returns: Void.
                     Affects: Initializes class member variables _strInterp, _strExcList.
                     Exceptions: None.
                     """
                     if not exceptionList:
                         exceptionList = traceback.format_exception(sys.exc_info()[0],
                                                                     sys.exc_info()[1],
                                                                     sys.exc_info()[2])
                     self._strInterp = strInterpretation
                     self._strExcList = exceptionList
                 def getExceptionStr(self):
                     """ getExceptionStr returns a formatted string ready for printing completely describing the exception.
                     Inputs: None
                     Returns: A formatted string ready for printing completely describing the exception.
                     Affects: None
                     Exceptions: None.
                     """
                     excStr = ''
                     excStr = excStr + self._strInterp + '\n\n'
                     if self._strExcList != None:
                         for item in self._strExcList:
                             excStr = excStr + str(item) + '\n'
                     return excStr
                 def __str__(self):
                     return(self.getExceptionStr())
                 def getExceptionHtml(self):
                     """ getExceptionHtml returns an Html formatted string completely describing the exception.
                     Inputs: None
                     Returns: A formatted string ready for printing completely describing the exception.
                     Affects: None
                     Exceptions: None.
                     """
                     excStr = '<BR>The following Schain Python exception has occurred:\n<BR>'
                     excStr = excStr + self._strInterp + '\n<BR>\n'
                     if self._strExcList != None:
                         for item in self._strExcList:
                             excStr = excStr + str(item) + '\n<BR>'
                     return excStr
             class SchainWarning(Exception):
                 pass
             if __name__ == '__main__':
                 test = SchainNotify()
                 test.sendAlert('This is a message from the python module SchainNotify', 'Test from SchainNotify')
                 print('Hopefully message sent - check.')

schainpy/controller.py +2 -4

             '''
             Updated on January , 2018, for multiprocessing purposes
             Author: Sergio Cortez
             Created on September , 2012
             '''
             from platform import python_version
             import sys
             import ast
             import datetime
             import traceback
             import math
             import time
             import zmq
             from multiprocessing import Process, cpu_count
             from threading import Thread
             from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
             from xml.dom import minidom
             from schainpy.admin import Alarm, SchainWarning
             ### Temporary imports!!!
             # from schainpy.model import *
             from schainpy.model.io import *
             from schainpy.model.graphics import *
             from schainpy.model.proc.jroproc_base import *
             from schainpy.model.proc.bltrproc_parameters import *
             from schainpy.model.proc.jroproc_spectra import *
             from schainpy.model.proc.jroproc_voltage import *
             from schainpy.model.proc.jroproc_parameters import *
             from schainpy.model.utils.jroutils_publish import *
             from schainpy.utils import log
             ###
             DTYPES = {
                 'Voltage': '.r',
                 'Spectra': '.pdata'
             }
             def MPProject(project, n=cpu_count()):
                 '''
                 Project wrapper to run schain in n processes
                 '''
                 rconf = project.getReadUnitObj()
                 op = rconf.getOperationObj('run')
                 dt1 = op.getParameterValue('startDate')
                 dt2 = op.getParameterValue('endDate')
                 tm1 = op.getParameterValue('startTime')
                 tm2 = op.getParameterValue('endTime')
                 days = (dt2 - dt1).days
                 for day in range(days + 1):
                     skip = 0
                     cursor = 0
                     processes = []
                     dt = dt1 + datetime.timedelta(day)
                     dt_str = dt.strftime('%Y/%m/%d')
                     reader = JRODataReader()
                     paths, files = reader.searchFilesOffLine(path=rconf.path,
                                                              startDate=dt,
                                                              endDate=dt,
                                                              startTime=tm1,
                                                              endTime=tm2,
                                                              ext=DTYPES[rconf.datatype])
                     nFiles = len(files)
                     if nFiles == 0:
                         continue
                     skip = int(math.ceil(nFiles / n))
                     while nFiles > cursor * skip:
                         rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,
                                      skip=skip)
                         p = project.clone()
                         p.start()
                         processes.append(p)
                         cursor += 1
                     def beforeExit(exctype, value, trace):
                         for process in processes:
                             process.terminate()
                             process.join()
                         print(traceback.print_tb(trace))
                     sys.excepthook = beforeExit
                     for process in processes:
                         process.join()
                         process.terminate()
                     time.sleep(3)
             def wait(context):
                 time.sleep(1)
                 c = zmq.Context()
                 receiver = c.socket(zmq.SUB)
                 receiver.connect('ipc:///tmp/schain_{}_pub'.format(self.id))
                 receiver.setsockopt(zmq.SUBSCRIBE, self.id.encode())
-                log.error('startinggg')
                 msg = receiver.recv_multipart()[1]
-                #log.error(msg)
                 context.terminate()
             class ParameterConf():
                 id = None
                 name = None
                 value = None
                 format = None
                 __formated_value = None
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.format = 'str'
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getValue(self):
                     value = self.value
                     format = self.format
                     if self.__formated_value != None:
                         return self.__formated_value
                     if format == 'obj':
                         return value
                     if format == 'str':
                         self.__formated_value = str(value)
                         return self.__formated_value
                     if value == '':
                         raise ValueError('%s: This parameter value is empty' % self.name)
                     if format == 'list':
                         strList = value.split(',')
                         self.__formated_value = strList
                         return self.__formated_value
                     if format == 'intlist':
                         '''
                         Example:
                             value = (0,1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [int(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'floatlist':
                         '''
                         Example:
                             value = (0.5, 1.4, 2.7)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             new_value = [float(new_value)]
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'date':
                         strList = value.split('/')
                         intList = [int(x) for x in strList]
                         date = datetime.date(intList[0], intList[1], intList[2])
                         self.__formated_value = date
                         return self.__formated_value
                     if format == 'time':
                         strList = value.split(':')
                         intList = [int(x) for x in strList]
                         time = datetime.time(intList[0], intList[1], intList[2])
                         self.__formated_value = time
                         return self.__formated_value
                     if format == 'pairslist':
                         '''
                         Example:
                             value = (0,1),(1,2)
                         '''
                         new_value = ast.literal_eval(value)
                         if type(new_value) not in (tuple, list):
                             raise ValueError('%s has to be a tuple or list of pairs' % value)
                         if type(new_value[0]) not in (tuple, list):
                             if len(new_value) != 2:
                                 raise ValueError('%s has to be a tuple or list of pairs' % value)
                             new_value = [new_value]
                         for thisPair in new_value:
                             if len(thisPair) != 2:
                                 raise ValueError('%s has to be a tuple or list of pairs' % value)
                         self.__formated_value = new_value
                         return self.__formated_value
                     if format == 'multilist':
                         '''
                         Example:
                             value = (0,1,2),(3,4,5)
                         '''
                         multiList = ast.literal_eval(value)
                         if type(multiList[0]) == int:
                             multiList = ast.literal_eval('(' + value + ')')
                         self.__formated_value = multiList
                         return self.__formated_value
                     if format == 'bool':
                         value = int(value)
                     if format == 'int':
                         value = float(value)
                     format_func = eval(format)
                     self.__formated_value = format_func(value)
                     return self.__formated_value
                 def updateId(self, new_id):
                     self.id = str(new_id)
                 def setup(self, id, name, value, format='str'):
                     self.id = str(id)
                     self.name = name
                     if format == 'obj':
                         self.value = value
                     else:
                         self.value = str(value)
                     self.format = str.lower(format)
                     self.getValue()
                     return 1
                 def update(self, name, value, format='str'):
                     self.name = name
                     self.value = str(value)
                     self.format = format
                 def makeXml(self, opElement):
                     if self.name not in ('queue',):
                         parmElement = SubElement(opElement, self.ELEMENTNAME)
                         parmElement.set('id', str(self.id))
                         parmElement.set('name', self.name)
                         parmElement.set('value', self.value)
                         parmElement.set('format', self.format)
                 def readXml(self, parmElement):
                     self.id = parmElement.get('id')
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                     self.format = str.lower(parmElement.get('format'))
                     # Compatible with old signal chain version
                     if self.format == 'int' and self.name == 'idfigure':
                         self.name = 'id'
                 def printattr(self):
                     print('Parameter[%s]: name = %s, value = %s, format = %s, project_id = %s' % (self.id, self.name, self.value, self.format, self.project_id))
             class OperationConf():
                 ELEMENTNAME = 'Operation'
                 def __init__(self):
                     self.id = '0'
                     self.name = None
                     self.priority = None
                     self.topic = None
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.parmConfObjList) + 1
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     n = 1
                     for parmObj in self.parmConfObjList:
                         idParm = str(int(new_id) * 10 + n)
                         parmObj.updateId(idParm)
                         n += 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getParameterObjList(self):
                     return self.parmConfObjList
                 def getParameterObj(self, parameterName):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.name != parameterName:
                             continue
                         return parmConfObj
                     return None
                 def getParameterObjfromValue(self, parameterValue):
                     for parmConfObj in self.parmConfObjList:
                         if parmConfObj.getValue() != parameterValue:
                             continue
                         return parmConfObj.getValue()
                     return None
                 def getParameterValue(self, parameterName):
                     parameterObj = self.getParameterObj(parameterName)
                 #         if not parameterObj:
                 #             return None
                     value = parameterObj.getValue()
                     return value
                 def getKwargs(self):
                     kwargs = {}
                     for parmConfObj in self.parmConfObjList:
                         if self.name == 'run' and parmConfObj.name == 'datatype':
                             continue
                         kwargs[parmConfObj.name] = parmConfObj.getValue()
                     return kwargs
                 def setup(self, id, name, priority, type, project_id):
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.type = type
                     self.priority = priority
                     self.parmConfObjList = []
                 def removeParameters(self):
                     for obj in self.parmConfObjList:
                         del obj
                     self.parmConfObjList = []
                 def addParameter(self, name, value, format='str'):
                     if value is None:
                         return None
                     id = self.__getNewId()
                     parmConfObj = ParameterConf()
                     if not parmConfObj.setup(id, name, value, format):
                         return None
                     self.parmConfObjList.append(parmConfObj)
                     return parmConfObj
                 def changeParameter(self, name, value, format='str'):
                     parmConfObj = self.getParameterObj(name)
                     parmConfObj.update(name, value, format)
                     return parmConfObj
                 def makeXml(self, procUnitElement):
                     opElement = SubElement(procUnitElement, self.ELEMENTNAME)
                     opElement.set('id', str(self.id))
                     opElement.set('name', self.name)
                     opElement.set('type', self.type)
                     opElement.set('priority', str(self.priority))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.makeXml(opElement)
                 def readXml(self, opElement, project_id):
                     self.id = opElement.get('id')
                     self.name = opElement.get('name')
                     self.type = opElement.get('type')
                     self.priority = opElement.get('priority')
                     self.project_id = str(project_id)  #yong
                     # Compatible with old signal chain version
                     # Use of 'run' method instead 'init'
                     if self.type == 'self' and self.name == 'init':
                         self.name = 'run'
                     self.parmConfObjList = []
                     parmElementList = opElement.iter(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         # Compatible with old signal chain version
                         # If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
                         if self.type != 'self' and self.name == 'Plot':
                             if parmConfObj.format == 'str' and parmConfObj.name == 'type':
                                 self.name = parmConfObj.value
                                 continue
                         self.parmConfObjList.append(parmConfObj)
                 def printattr(self):
                     print('%s[%s]: name = %s, type = %s, priority = %s, project_id = %s' % (self.ELEMENTNAME,
                                                                            self.id,
                                                                            self.name,
                                                                            self.type,
                                                                            self.priority,
                                                                            self.project_id))
                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
                 def createObject(self):
                     className = eval(self.name)
                     if self.type == 'other':
                         opObj = className()
                     elif self.type == 'external':
                         kwargs = self.getKwargs()
                         opObj = className(self.id, self.project_id, **kwargs)
                         opObj.start()
                     return opObj
             class ProcUnitConf():
                 ELEMENTNAME = 'ProcUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                     self.procUnitObj = None
                     self.opObjDict = {}
                 def __getPriority(self):
                     return len(self.opConfObjList) + 1
                 def __getNewId(self):
                     return int(self.id) * 10 + len(self.opConfObjList) + 1
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     '''
                     new_id = int(parentId) * 10 + (int(self.id) % 10)
                     new_inputId = int(parentId) * 10 + (int(self.inputId) % 10)
                     # If this proc unit has not inputs
                     #if self.inputId == '0':
                         #new_inputId = 0
                     n = 1
                     for opConfObj in self.opConfObjList:
                         idOp = str(int(new_id) * 10 + n)
                         opConfObj.updateId(idOp)
                         n += 1
                     self.parentId = str(parentId)
                     self.id = str(new_id)
                     #self.inputId = str(new_inputId)
                     '''
                     n = 1
                 def getInputId(self):
                     return self.inputId
                 def getOperationObjList(self):
                     return self.opConfObjList
                 def getOperationObj(self, name=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.name != name:
                             continue
                         return opConfObj
                     return None
                 def getOpObjfromParamValue(self, value=None):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
                             continue
                         return opConfObj
                     return None
                 def getProcUnitObj(self):
                     return self.procUnitObj
                 def setup(self, project_id, id, name, datatype, inputId):
                     '''
                         id sera el topico a publicar
                         inputId sera el topico a subscribirse
                     '''
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     #Definir una condicion para inputId cuando sea 0
                     if name == None:
                         if 'Proc' in datatype:
                             name = datatype
                         else:
                             name = '%sProc' % (datatype)
                     if datatype == None:
                         datatype = name.replace('Proc', '')
                     self.id = str(id)
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     self.inputId = inputId
                     self.opConfObjList = []
                     self.addOperation(name='run', optype='self')
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                     self.addOperation(name='run')
                 def addParameter(self, **kwargs):
                     '''
                     Add parameters to 'run' operation
                     '''
                     opObj = self.opConfObjList[0]
                     opObj.addParameter(**kwargs)
                     return opObj
                 def addOperation(self, name, optype='self'):
                     '''
                         Actualizacion - > proceso comunicacion
                         En el caso de optype='self', elminar. DEfinir comuncacion IPC -> Topic
                         definir el tipoc de socket o comunicacion ipc++
                     '''
                     id = self.__getNewId()
                     priority = self.__getPriority() # Sin mucho sentido, pero puede usarse
                     opConfObj = OperationConf()
                     opConfObj.setup(id, name=name, priority=priority, type=optype, project_id=self.project_id)
                     self.opConfObjList.append(opConfObj)
                     return opConfObj
                 def makeXml(self, projectElement):
                     procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
                     procUnitElement.set('id', str(self.id))
                     procUnitElement.set('name', self.name)
                     procUnitElement.set('datatype', self.datatype)
                     procUnitElement.set('inputId', str(self.inputId))
                     for opConfObj in self.opConfObjList:
                         opConfObj.makeXml(procUnitElement)
                 def readXml(self, upElement, project_id):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.inputId = upElement.get('inputId')
                     self.project_id = str(project_id)
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     if self.ELEMENTNAME == 'ProcUnit':
                         self.datatype = self.datatype.replace('Proc', '')
                     if self.inputId == 'None':
                         self.inputId = '0'
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement, project_id)
                         self.opConfObjList.append(opConfObj)
                 def printattr(self):
                     print('%s[%s]: name = %s, datatype = %s, inputId = %s, project_id = %s' % (self.ELEMENTNAME,
                                                                               self.id,
                                                                               self.name,
                                                                               self.datatype,
                                                                               self.inputId,
                                                                               self.project_id))
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
                 def getKwargs(self):
                     opObj = self.opConfObjList[0]
                     kwargs = opObj.getKwargs()
                     return kwargs
                 def createObjects(self):
                     '''
                     Instancia de unidades de procesamiento.
                     '''
                     className = eval(self.name)
                     kwargs = self.getKwargs()
                     procUnitObj = className(self.id, self.inputId, self.project_id, **kwargs) # necesitan saber su id y su entrada por fines de ipc
                     log.success('creating process...', self.name)
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self' and opConfObj.name == 'run':
                             continue
                         elif opConfObj.type == 'self':
                             opObj = getattr(procUnitObj, opConfObj.name)
                         else:
                             opObj = opConfObj.createObject()
                         log.success('creating operation: {}, type:{}'.format(
                             opConfObj.name,
                             opConfObj.type), self.name)
                         procUnitObj.addOperation(opConfObj, opObj)
                     procUnitObj.start()
                     self.procUnitObj = procUnitObj
                 def close(self):
                     for opConfObj in self.opConfObjList:
                         if opConfObj.type == 'self':
                             continue
                         opObj = self.procUnitObj.getOperationObj(opConfObj.id)
                         opObj.close()
                     self.procUnitObj.close()
                     return
             class ReadUnitConf(ProcUnitConf):
                 ELEMENTNAME = 'ReadUnit'
                 def __init__(self):
                     self.id = None
                     self.datatype = None
                     self.name = None
                     self.inputId = None
                     self.opConfObjList = []
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def setup(self, project_id, id, name, datatype, path='', startDate='', endDate='',
                           startTime='', endTime='', server=None, **kwargs):
                     '''
                     *****el id del proceso sera el Topico
                     Adicion de {topic}, si no esta presente -> error
                     kwargs deben ser trasmitidos en la instanciacion
                     '''
                     # Compatible with old signal chain version
                     if datatype == None and name == None:
                         raise ValueError('datatype or name should be defined')
                     if name == None:
                         if 'Reader' in datatype:
                             name = datatype
                             datatype = name.replace('Reader','')
                         else:
                             name = '{}Reader'.format(datatype)
                     if datatype == None:
                         if 'Reader' in name:
                             datatype = name.replace('Reader','')
                         else:
                             datatype = name
                             name = '{}Reader'.format(name)
                     self.id = id
                     self.project_id = project_id
                     self.name = name
                     self.datatype = datatype
                     if path != '':
                         self.path = os.path.abspath(path)
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.server = server
                     self.addRunOperation(**kwargs)
                 def update(self, **kwargs):
                     if 'datatype' in kwargs:
                         datatype = kwargs.pop('datatype')
                         if 'Reader' in datatype:
                             self.name = datatype
                         else:
                             self.name = '%sReader' % (datatype)
                         self.datatype = self.name.replace('Reader', '')
                     attrs = ('path', 'startDate', 'endDate',
                              'startTime', 'endTime')
                     for attr in attrs:
                         if attr in kwargs:
                             setattr(self, attr, kwargs.pop(attr))
                     self.updateRunOperation(**kwargs)
                 def removeOperations(self):
                     for obj in self.opConfObjList:
                         del obj
                     self.opConfObjList = []
                 def addRunOperation(self, **kwargs):
                     opObj = self.addOperation(name='run', optype='self')
                     if self.server is None:
                         opObj.addParameter(
                             name='datatype', value=self.datatype, format='str')
                         opObj.addParameter(name='path', value=self.path, format='str')
                         opObj.addParameter(
                             name='startDate', value=self.startDate, format='date')
                         opObj.addParameter(
                             name='endDate', value=self.endDate, format='date')
                         opObj.addParameter(
                             name='startTime', value=self.startTime, format='time')
                         opObj.addParameter(
                             name='endTime', value=self.endTime, format='time')
                         for key, value in list(kwargs.items()):
                             opObj.addParameter(name=key, value=value,
                                                format=type(value).__name__)
                     else:
                         opObj.addParameter(name='server', value=self.server, format='str')
                     return opObj
                 def updateRunOperation(self, **kwargs):
                     opObj = self.getOperationObj(name='run')
                     opObj.removeParameters()
                     opObj.addParameter(name='datatype', value=self.datatype, format='str')
                     opObj.addParameter(name='path', value=self.path, format='str')
                     opObj.addParameter(
                         name='startDate', value=self.startDate, format='date')
                     opObj.addParameter(name='endDate', value=self.endDate, format='date')
                     opObj.addParameter(
                         name='startTime', value=self.startTime, format='time')
                     opObj.addParameter(name='endTime', value=self.endTime, format='time')
                     for key, value in list(kwargs.items()):
                         opObj.addParameter(name=key, value=value,
                                            format=type(value).__name__)
                     return opObj
                 def readXml(self, upElement, project_id):
                     self.id = upElement.get('id')
                     self.name = upElement.get('name')
                     self.datatype = upElement.get('datatype')
                     self.project_id = str(project_id)  #yong
                     if self.ELEMENTNAME == 'ReadUnit':
                         self.datatype = self.datatype.replace('Reader', '')
                     self.opConfObjList = []
                     opElementList = upElement.iter(OperationConf().getElementName())
                     for opElement in opElementList:
                         opConfObj = OperationConf()
                         opConfObj.readXml(opElement, project_id)
                         self.opConfObjList.append(opConfObj)
                         if opConfObj.name == 'run':
                             self.path = opConfObj.getParameterValue('path')
                             self.startDate = opConfObj.getParameterValue('startDate')
                             self.endDate = opConfObj.getParameterValue('endDate')
                             self.startTime = opConfObj.getParameterValue('startTime')
                             self.endTime = opConfObj.getParameterValue('endTime')
             class Project(Process):
                 ELEMENTNAME = 'Project'
                 def __init__(self):
                     Process.__init__(self)
                     self.id = None
                     self.filename = None
                     self.description = None
                     self.email = None
                     self.alarm = None
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                     idList = list(self.procUnitConfObjDict.keys())
                     id = int(self.id) * 10
                     while True:
                         id += 1
                         if str(id) in idList:
                             continue
                         break
                     return str(id)
                 def getElementName(self):
                     return self.ELEMENTNAME
                 def getId(self):
                     return self.id
                 def updateId(self, new_id):
                     self.id = str(new_id)
                     keyList = list(self.procUnitConfObjDict.keys())
                     keyList.sort()
                     n = 1
                     newProcUnitConfObjDict = {}
                     for procKey in keyList:
                         procUnitConfObj = self.procUnitConfObjDict[procKey]
                         idProcUnit = str(int(self.id) * 10 + n)
                         procUnitConfObj.updateId(idProcUnit)
                         newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
                         n += 1
                     self.procUnitConfObjDict = newProcUnitConfObjDict
                 def setup(self, id=1, name='', description='', email=None, alarm=[]):
                     print(' ')
                     print('*' * 60)
                     print('*  Starting SIGNAL CHAIN PROCESSING (Multiprocessing) v%s *' % schainpy.__version__)
                     print('*' * 60)
                     print("*  Python " + python_version() + "  *")
                     print('*' * 19)
                     print(' ')
                     self.id = str(id)
                     self.description = description
                     self.email = email
                     self.alarm = alarm
                 def update(self, **kwargs):
                     for key, value in list(kwargs.items()):
                         setattr(self, key, value)
                 def clone(self):
                     p = Project()
                     p.procUnitConfObjDict = self.procUnitConfObjDict
                     return p
                 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
                     '''
                     Actualizacion:
                         Se agrego un nuevo argumento: topic -relativo a la forma de comunicar los procesos simultaneos
                         * El id del proceso sera el topico al que se deben subscribir los procUnits para recibir la informacion(data)
                     '''
                     if id is None:
                         idReadUnit = self.__getNewId()
                     else:
                         idReadUnit = str(id)
                     readUnitConfObj = ReadUnitConf()
                     readUnitConfObj.setup(self.id, idReadUnit, name, datatype, **kwargs)
                     self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     return readUnitConfObj
                 def addProcUnit(self, inputId='0', datatype=None, name=None):
                     '''
                     Actualizacion:
                         Se agrego dos nuevos argumentos: topic_read (lee data de otro procUnit) y topic_write(escribe o envia data a otro procUnit)
                         Deberia reemplazar a "inputId"
                         ** A fin de mantener el inputID, este sera la representaacion del topicoal que deben subscribirse. El ID propio de la intancia
                         (proceso) sera el topico de la publicacion, todo sera asignado de manera dinamica.
                     '''
                     idProcUnit = self.__getNewId() #Topico para subscripcion
                     procUnitConfObj = ProcUnitConf()
                     procUnitConfObj.setup(self.id, idProcUnit, name, datatype, inputId) #topic_read, topic_write,
                     self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def removeProcUnit(self, id):
                     if id in list(self.procUnitConfObjDict.keys()):
                         self.procUnitConfObjDict.pop(id)
                 def getReadUnitId(self):
                     readUnitConfObj = self.getReadUnitObj()
                     return readUnitConfObj.id
                 def getReadUnitObj(self):
                     for obj in list(self.procUnitConfObjDict.values()):
                         if obj.getElementName() == 'ReadUnit':
                             return obj
                     return None
                 def getProcUnitObj(self, id=None, name=None):
                     if id != None:
                         return self.procUnitConfObjDict[id]
                     if name != None:
                         return self.getProcUnitObjByName(name)
                     return None
                 def getProcUnitObjByName(self, name):
                     for obj in list(self.procUnitConfObjDict.values()):
                         if obj.name == name:
                             return obj
                     return None
                 def procUnitItems(self):
                     return list(self.procUnitConfObjDict.items())
                 def makeXml(self):
                     projectElement = Element('Project')
                     projectElement.set('id', str(self.id))
                     projectElement.set('name', self.name)
                     projectElement.set('description', self.description)
                     for procUnitConfObj in list(self.procUnitConfObjDict.values()):
                         procUnitConfObj.makeXml(projectElement)
                     self.projectElement = projectElement
                 def writeXml(self, filename=None):
                     if filename == None:
                         if self.filename:
                             filename = self.filename
                         else:
                             filename = 'schain.xml'
                     if not filename:
                         print('filename has not been defined. Use setFilename(filename) for do it.')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.access(os.path.dirname(abs_file), os.W_OK):
                         print('No write permission on %s' % os.path.dirname(abs_file))
                         return 0
                     if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
                         print('File %s already exists and it could not be overwriten' % abs_file)
                         return 0
                     self.makeXml()
                     ElementTree(self.projectElement).write(abs_file, method='xml')
                     self.filename = abs_file
                     return 1
                 def readXml(self, filename=None):
                     if not filename:
                         print('filename is not defined')
                         return 0
                     abs_file = os.path.abspath(filename)
                     if not os.path.isfile(abs_file):
                         print('%s file does not exist' % abs_file)
                         return 0
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     try:
                         self.projectElement = ElementTree().parse(abs_file)
                     except:
                         print('Error reading %s, verify file format' % filename)
                         return 0
                     self.project = self.projectElement.tag
                     self.id = self.projectElement.get('id')
                     self.name = self.projectElement.get('name')
                     self.description = self.projectElement.get('description')
                     readUnitElementList = self.projectElement.iter(
                         ReadUnitConf().getElementName())
                     for readUnitElement in readUnitElementList:
                         readUnitConfObj = ReadUnitConf()
                         readUnitConfObj.readXml(readUnitElement, self.id)
                         self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
                     procUnitElementList = self.projectElement.iter(
                         ProcUnitConf().getElementName())
                     for procUnitElement in procUnitElementList:
                         procUnitConfObj = ProcUnitConf()
                         procUnitConfObj.readXml(procUnitElement, self.id)
                         self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     self.filename = abs_file
                     return 1
                 def __str__(self):
                     print('Project[%s]: name = %s, description = %s, project_id = %s' % (self.id,
                                                                         self.name,
                                                                         self.description,
                                                                         self.project_id))
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         print(procUnitConfObj)
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
                         procUnitConfObj.createObjects()
                 def __handleError(self, procUnitConfObj, modes=None, stdout=True):
                     import socket
                     if modes is None:
                         modes = self.alarm
                     if not self.alarm:
                         modes = []
                     err = traceback.format_exception(sys.exc_info()[0],
                                                      sys.exc_info()[1],
                                                      sys.exc_info()[2])
                     log.error('{}'.format(err[-1]), procUnitConfObj.name)
                     message = ''.join(err)
                     if stdout:
                         sys.stderr.write(message)
                     subject = 'SChain v%s: Error running %s\n' % (
                         schainpy.__version__, procUnitConfObj.name)
                     subtitle = '%s: %s\n' % (
                         procUnitConfObj.getElementName(), procUnitConfObj.name)
                     subtitle += 'Hostname: %s\n' % socket.gethostbyname(
                         socket.gethostname())
                     subtitle += 'Working directory: %s\n' % os.path.abspath('./')
                     subtitle += 'Configuration file: %s\n' % self.filename
                     subtitle += 'Time: %s\n' % str(datetime.datetime.now())
                     readUnitConfObj = self.getReadUnitObj()
                     if readUnitConfObj:
                         subtitle += '\nInput parameters:\n'
                         subtitle += '[Data path = %s]\n' % readUnitConfObj.path
                         subtitle += '[Data type = %s]\n' % readUnitConfObj.datatype
                         subtitle += '[Start date = %s]\n' % readUnitConfObj.startDate
                         subtitle += '[End date = %s]\n' % readUnitConfObj.endDate
                         subtitle += '[Start time = %s]\n' % readUnitConfObj.startTime
                         subtitle += '[End time = %s]\n' % readUnitConfObj.endTime
                     a = Alarm(
                         modes=modes,
                         email=self.email,
                         message=message,
                         subject=subject,
                         subtitle=subtitle,
                         filename=self.filename
                     )
                     return a
                 def isPaused(self):
                     return 0
                 def isStopped(self):
                     return 0
                 def runController(self):
                     '''
                     returns 0 when this process has been stopped, 1 otherwise
                     '''
                     if self.isPaused():
                         print('Process suspended')
                         while True:
                             time.sleep(0.1)
                             if not self.isPaused():
                                 break
                             if self.isStopped():
                                 break
                         print('Process reinitialized')
                     if self.isStopped():
                         print('Process stopped')
                         return 0
                     return 1
                 def setFilename(self, filename):
                     self.filename = filename
                 def setProxyCom(self):
                     if not os.path.exists('/tmp/schain'):
                         os.mkdir('/tmp/schain')
                     self.ctx = zmq.Context()
                     xpub = self.ctx.socket(zmq.XPUB)
                     xpub.bind('ipc:///tmp/schain/{}_pub'.format(self.id))
                     xsub = self.ctx.socket(zmq.XSUB)
                     xsub.bind('ipc:///tmp/schain/{}_sub'.format(self.id))
                     try:
                         zmq.proxy(xpub, xsub)
-                    except zmq.ContextTerminated:
+                    except: # zmq.ContextTerminated:
                         xpub.close()
                         xsub.close()
                 def run(self):
                     log.success('Starting {}: {}'.format(self.name, self.id), tag='')
                     self.start_time = time.time()
                     self.createObjects()
                     # t = Thread(target=wait, args=(self.ctx, ))
                     # t.start()
                     self.setProxyCom()
                     # Iniciar todos los procesos .start(), monitoreo de procesos. ELiminar lo de abajo
-                    log.success('{} finished (time: {}s)'.format(
+                    log.success('{} Done (time: {}s)'.format(
                         self.name,
                         time.time()-self.start_time))

schainpy/model/data/jrodata.py +263 -172

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
+            import json
+            from schainpy.utils import log
             from .jroheaderIO import SystemHeader, RadarControllerHeader
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                 else:
                     raise ValueError('dataTypeCode was not defined')
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real', '<i1'), ('imag', '<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real', '<i2'), ('imag', '<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real', '<i4'), ('imag', '<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real', '<i8'), ('imag', '<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real', '<f4'), ('imag', '<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real', '<f8'), ('imag', '<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     mean    :    noise's level
                 """
                 sortdata = numpy.sort(data, axis=None)
                 lenOfData = len(sortdata)
                 nums_min = lenOfData*0.2
                 if nums_min <= 5:
                     nums_min = 5
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
-                while((cont==1)and(j<lenOfData)):
+                while((cont == 1)and(j < lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
-                            sump  = sump - sortdata[j]
+                            sump = sump - sortdata[j]
-                            sumq =  sumq - sortdata[j]**2
+                            sumq = sumq - sortdata[j]**2
                             cont = 0
                     j += 1
-                lnoise = sump /j
+                lnoise = sump / j
                 return lnoise
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in list(inputObj.__dict__.keys()):
                         attribute = inputObj.__dict__[key]
                         # If this attribute is a tuple or list
                         if type(inputObj.__dict__[key]) in (tuple, list):
                             self.__dict__[key] = attribute[:]
                             continue
                         # If this attribute is another object or instance
                         if hasattr(attribute, '__dict__'):
                             self.__dict__[key] = attribute.copy()
                             continue
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
             class JROData(GenericData):
                 #    m_BasicHeader = BasicHeader()
                 #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None  # dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #     nBaud = None
             #     code = None
                 flagDecodeData = False  # asumo q la data no esta decodificada
                 flagDeflipData = False  # asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 # Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
+                error = None
+                data = None
+                data_plt = None
-                error = (0, '')
                 def __str__(self):
                     return '{} - {}'.format(self.type, self.getDatatime())
                 def getNoise(self):
                     raise NotImplementedError
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getDeltaH(self):
                     delta = self.heightList[1] - self.heightList[0]
                     return delta
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 def getDatatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval + 1)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmaxTimeResponse(self):
                     period = (10**-6) * self.getDeltaH() / (0.15)
                     PRF = 1. / (period * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getFmax(self):
                     PRF = 1. / (self.ippSeconds * self.nCohInt)
                     fmax = PRF
                     return fmax
                 def getVmax(self):
                     _lambda = self.C / self.frequency
                     vmax = self.getFmax() * _lambda / 2
                     return vmax
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(
                     getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 # data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
+                    self.heightList = Non
-                    self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False  # Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 def getNoisebyHildebrand(self, channel=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel, :].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type=1, channel=None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return noise
                 def getPower(self, channel=None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     powerdB = 10 * numpy.log10(power.real)
                     powerdB = numpy.squeeze(powerdB)
                     return powerdB
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 # data spc es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 # data cspc es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 # data dc es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 # data power
                 data_pwr = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None  # Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None  # se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 plotting = "spectra"
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,
                                              xmin_index:xmax_index, ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation is not None:
                         # this was estimated by getNoise Operation defined in jroproc_spectra.py
                         return self.noise_estimation
                     else:
                         noise = self.getNoisebyHildebrand(
                             xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRangeTimeResponse(self, extrapoints=0):
                     deltafreq = self.getFmaxTimeResponse() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * \
                         (numpy.arange(self.nFFTPoints + extrapoints) -
                          self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getAcfRange(self, extrapoints=0):
                     deltafreq = 10. / (self.getFmax() / (self.nFFTPoints * self.ippFactor))
                     freqrange = deltafreq * \
                         (numpy.arange(self.nFFTPoints + extrapoints) -
                          self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints * self.ippFactor)
                     freqrange = deltafreq * \
                         (numpy.arange(self.nFFTPoints + extrapoints) -
                          self.nFFTPoints / 2.) - deltafreq / 2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints * self.ippFactor)
                     velrange = deltav * (numpy.arange(self.nFFTPoints +
                                                       extrapoints) - self.nFFTPoints / 2.)  # - deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return list(range(self.nPairs))
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles * self.nIncohInt * \
                         self.nCohInt * pwcode * self.windowOfFilter
                     return normFactor
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
-                    timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles * self.ippFactor
+                    timeInterval = self.ippSeconds * self.nCohInt * \
+                        self.nIncohInt * self.nProfiles * self.ippFactor
                     return timeInterval
                 def getPower(self):
                     factor = self.normFactor
                     z = self.data_spc / factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     return 10 * numpy.log10(avg)
                 def getCoherence(self, pairsList=None, phase=False):
                     z = []
                     if pairsList is None:
                         pairsIndexList = self.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in self.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" % (
                                     pair))
                             pairsIndexList.append(self.pairsList.index(pair))
                     for i in range(len(pairsIndexList)):
                         pair = self.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(
                             self.data_cspc[pairsIndexList[i], :, :], axis=0)
                         powa = numpy.average(self.data_spc[pair[0], :, :], axis=0)
                         powb = numpy.average(self.data_spc[pair[1], :, :], axis=0)
                         avgcoherenceComplex = ccf / numpy.sqrt(powa * powb)
                         if phase:
                             data = numpy.arctan2(avgcoherenceComplex.imag,
                                                  avgcoherenceComplex.real) * 180 / numpy.pi
                         else:
                             data = numpy.abs(avgcoherenceComplex)
                         z.append(data)
                     return numpy.array(z)
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(
                     getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue,
                                       "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue,
                                         "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt * self.nCohInt * pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 # Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone * 60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return list(range(self.nChannels))
                 def getNoise(self, type=1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(
                     getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 #--------------------------------------------------
                 mode = None
                 split = False
                 data_cf = None
                 lags = None
                 lagRange = None
                 pairsList = None
                 normFactor = None
                 #--------------------------------------------------
             #     calculateVelocity = None
                 nLags = None
                 nPairs = None
                 nAvg = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False  # asumo q la data no esta decodificada
                     self.flagDeflipData = False  # asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getPairsList(self):
                     return self.pairsList
                 def getNoise(self, mode=2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:, :, indR, :]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1] / 2
                     ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
                     if ind_vel[0] < 0:
-                        ind_vel[list(range(0, 1))] = ind_vel[list(range(0, 1))] + self.num_prof
+                        ind_vel[list(range(0, 1))] = ind_vel[list(
+                            range(0, 1))] + self.num_prof
                     if mode == 1:
                         jspectra[:, freq_dc, :] = (
                             jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2, -1, 1, 2])
                         xx = numpy.zeros([4, 4])
                         for fil in range(4):
                             xx[fil, :] = vel[fil]**numpy.asarray(list(range(4)))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0, :]
                         for ich in range(num_chan):
                             yy = jspectra[ich, ind_vel, :]
                             jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
                             junkid = jspectra[ich, freq_dc, :] <= 0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich, freq_dc, junkid.nonzero()] = (
                                     jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
                     noise = jspectra0[:, freq_dc, :] - jspectra[:, freq_dc, :]
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nProfiles
                     return timeInterval
                 def splitFunctions(self):
                     pairsList = self.pairsList
                     ccf_pairs = []
                     acf_pairs = []
                     ccf_ind = []
                     acf_ind = []
                     for l in range(len(pairsList)):
                         chan0 = pairsList[l][0]
                         chan1 = pairsList[l][1]
                         # Obteniendo pares de Autocorrelacion
                         if chan0 == chan1:
                             acf_pairs.append(chan0)
                             acf_ind.append(l)
                         else:
                             ccf_pairs.append(pairsList[l])
                             ccf_ind.append(l)
                     data_acf = self.data_cf[acf_ind]
                     data_ccf = self.data_cf[ccf_ind]
                     return acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf
                 def getNormFactor(self):
                     acf_ind, ccf_ind, acf_pairs, ccf_pairs, data_acf, data_ccf = self.splitFunctions()
                     acf_pairs = numpy.array(acf_pairs)
                     normFactor = numpy.zeros((self.nPairs, self.nHeights))
                     for p in range(self.nPairs):
                         pair = self.pairsList[p]
                         ch0 = pair[0]
                         ch1 = pair[1]
                         ch0_max = numpy.max(data_acf[acf_pairs == ch0, :, :], axis=1)
                         ch1_max = numpy.max(data_acf[acf_pairs == ch1, :, :], axis=1)
                         normFactor[p, :] = numpy.sqrt(ch0_max * ch1_max)
                     return normFactor
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 normFactor = property(getNormFactor, "I'm the 'normFactor property'")
             class Parameters(Spectra):
                 experimentInfo = None  # Information about the experiment
                 # Information from previous data
                 inputUnit = None  # Type of data to be processed
                 operation = None  # Type of operation to parametrize
                 # normFactor = None       #Normalization Factor
                 groupList = None  # List of Pairs, Groups, etc
                 # Parameters
                 data_param = None  # Parameters obtained
                 data_pre = None  # Data Pre Parametrization
                 data_SNR = None  # Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None  # Abscissa, can be velocities, lags or time
             #    noise = None            #Noise Potency
                 utctimeInit = None  # Initial UTC time
                 paramInterval = None  # Time interval to calculate Parameters in seconds
                 useLocalTime = True
                 # Fitting
                 data_error = None  # Error of the estimation
                 constants = None
                 library = None
                 # Output signal
                 outputInterval = None  # Time interval to calculate output signal in seconds
                 data_output = None  # Out signal
                 nAvg = None
                 noise_estimation = None
                 GauSPC = None  # Fit gaussian SPC
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self, interval):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone * 60
                     else:
                         time1 = self.utctimeInit
                     datatime.append(time1)
                     datatime.append(time1 + interval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getTimeInterval(self):
                     if hasattr(self, 'timeInterval1'):
                         return self.timeInterval1
                     else:
                         return self.paramInterval
                 def setValue(self, value):
                     print("This property should not be initialized")
                     return
                 def getNoise(self):
                     return self.spc_noise
                 timeInterval = property(getTimeInterval)
-                noise = property(getNoise, setValue, "I'm the 'Noise' property.")
  No newline at end of file
+                noise = property(getNoise, setValue, "I'm the 'Noise' property.")
+            class PlotterData(object):
+                '''
+                Object to hold data to be plotted
+                '''
+                MAXNUMX = 100
+                MAXNUMY = 100
+                def __init__(self, code, throttle_value, exp_code, buffering=True):
+                    self.throttle = throttle_value
+                    self.exp_code = exp_code
+                    self.buffering = buffering
+                    self.ready = False
+                    self.localtime = False
+                    self.data = {}
+                    self.meta = {}
+                    self.__times = []
+                    self.__heights = []
+                    if 'snr' in code:
+                        self.plottypes = ['snr']
+                    elif code == 'spc':
+                        self.plottypes = ['spc', 'noise', 'rti']
+                    elif code == 'rti':
+                        self.plottypes = ['noise', 'rti']
+                    else:
+                        self.plottypes = [code]
+                    for plot in self.plottypes:
+                        self.data[plot] = {}
+                def __str__(self):
+                    dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
+                    return 'Data[{}][{}]'.format(';'.join(dum), len(self.__times))
+                def __len__(self):
+                    return len(self.__times)
+                def __getitem__(self, key):
+                    if key not in self.data:
+                        raise KeyError(log.error('Missing key: {}'.format(key)))
+                    if 'spc' in key or not self.buffering:
+                        ret = self.data[key]
+                    else:
+                        ret = numpy.array([self.data[key][x] for x in self.times])
+                        if ret.ndim > 1:
+                            ret = numpy.swapaxes(ret, 0, 1)
+                    return ret
+                def __contains__(self, key):
+                    return key in self.data
+                def setup(self):
+                    '''
+                    Configure object
+                    '''
+                    self.type = ''
+                    self.ready = False
+                    self.data = {}
+                    self.__times = []
+                    self.__heights = []
+                    self.__all_heights = set()
+                    for plot in self.plottypes:
+                        if 'snr' in plot:
+                            plot = 'snr'
+                        self.data[plot] = {}
+                    if 'spc' in self.data or 'rti' in self.data:
+                        self.data['noise'] = {}
+                        if 'noise' not in self.plottypes:
+                            self.plottypes.append('noise')
+                def shape(self, key):
+                    '''
+                    Get the shape of the one-element data for the given key
+                    '''
+                    if len(self.data[key]):
+                        if 'spc' in key or not self.buffering:
+                            return self.data[key].shape
+                        return self.data[key][self.__times[0]].shape
+                    return (0,)
+                def update(self, dataOut, tm):
+                    '''
+                    Update data object with new dataOut
+                    '''
+                    if tm in self.__times:
+                        return
+                    self.type = dataOut.type
+                    self.parameters = getattr(dataOut, 'parameters', [])
+                    if hasattr(dataOut, 'pairsList'):
+                        self.pairs = dataOut.pairsList
+                    if hasattr(dataOut, 'meta'):
+                        self.meta = dataOut.meta
+                    self.channels = dataOut.channelList
+                    self.interval = dataOut.getTimeInterval()
+                    self.localtime = dataOut.useLocalTime
+                    if 'spc' in self.plottypes or 'cspc' in self.plottypes:
+                        self.xrange = (dataOut.getFreqRange(1)/1000.,
+                                       dataOut.getAcfRange(1), dataOut.getVelRange(1))
+                    self.__heights.append(dataOut.heightList)
+                    self.__all_heights.update(dataOut.heightList)
+                    self.__times.append(tm)
+                    for plot in self.plottypes:
+                        if plot == 'spc':
+                            z = dataOut.data_spc/dataOut.normFactor
+                            buffer = 10*numpy.log10(z)
+                        if plot == 'cspc':
+                            buffer = dataOut.data_cspc
+                        if plot == 'noise':
+                            buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                        if plot == 'rti':
+                            buffer = dataOut.getPower()
+                        if plot == 'snr_db':
+                            buffer = dataOut.data_SNR
+                        if plot == 'snr':
+                            buffer = 10*numpy.log10(dataOut.data_SNR)
+                        if plot == 'dop':
+                            buffer = 10*numpy.log10(dataOut.data_DOP)
+                        if plot == 'mean':
+                            buffer = dataOut.data_MEAN
+                        if plot == 'std':
+                            buffer = dataOut.data_STD
+                        if plot == 'coh':
+                            buffer = dataOut.getCoherence()
+                        if plot == 'phase':
+                            buffer = dataOut.getCoherence(phase=True)
+                        if plot == 'output':
+                            buffer = dataOut.data_output
+                        if plot == 'param':
+                            buffer = dataOut.data_param
+                        if 'spc' in plot:
+                            self.data[plot] = buffer
+                        else:
+                            if self.buffering:
+                                self.data[plot][tm] = buffer
+                            else:
+                                self.data[plot] = buffer
+                def normalize_heights(self):
+                    '''
+                    Ensure same-dimension of the data for different heighList
+                    '''
+                    H = numpy.array(list(self.__all_heights))
+                    H.sort()
+                    for key in self.data:
+                        shape = self.shape(key)[:-1] + H.shape
+                        for tm, obj in list(self.data[key].items()):
+                            h = self.__heights[self.__times.index(tm)]
+                            if H.size == h.size:
+                                continue
+                            index = numpy.where(numpy.in1d(H, h))[0]
+                            dummy = numpy.zeros(shape) + numpy.nan
+                            if len(shape) == 2:
+                                dummy[:, index] = obj
+                            else:
+                                dummy[index] = obj
+                            self.data[key][tm] = dummy
+                    self.__heights = [H for tm in self.__times]
+                def jsonify(self, decimate=False):
+                    '''
+                    Convert data to json
+                    '''
+                    data = {}
+                    tm = self.times[-1]
+                    dy = int(self.heights.size/self.MAXNUMY) + 1
+                    for key in self.data:
+                        if key in ('spc', 'cspc') or not self.buffering:
+                            dx = int(self.data[key].shape[1]/self.MAXNUMX) + 1
+                            data[key] = self.roundFloats(
+                                self.data[key][::, ::dx, ::dy].tolist())
+                        else:
+                            data[key] = self.roundFloats(self.data[key][tm].tolist())
+                    ret = {'data': data}
+                    ret['exp_code'] = self.exp_code
+                    ret['time'] = float(tm)
+                    ret['interval'] = float(self.interval)
+                    ret['localtime'] = self.localtime
+                    ret['yrange'] = self.roundFloats(self.heights[::dy].tolist())
+                    if 'spc' in self.data or 'cspc' in self.data:
+                        ret['xrange'] = self.roundFloats(self.xrange[2][::dx].tolist())
+                    else:
+                        ret['xrange'] = []
+                    if hasattr(self, 'pairs'):
+                        ret['pairs'] = [(int(p[0]), int(p[1])) for p in self.pairs]
+                    else:
+                        ret['pairs'] = []
+                    for key, value in list(self.meta.items()):
+                        ret[key] = value
+                    return json.dumps(ret)
+                @property
+                def times(self):
+                    '''
+                    Return the list of times of the current data
+                    '''
+                    ret = numpy.array(self.__times)
+                    ret.sort()
+                    return ret
+                @property
+                def min_time(self):
+                    '''
+                    Return the minimun time value
+                    '''
+                    return self.times[0]
+                @property
+                def max_time(self):
+                    '''
+                    Return the maximun time value
+                    '''
+                    return self.times[-1]
+                @property
+                def heights(self):
+                    '''
+                    Return the list of heights of the current data
+                    '''
+                    return numpy.array(self.__heights[-1])
+                @staticmethod
+                def roundFloats(obj):
+                    if isinstance(obj, list):
+                        return list(map(PlotterData.roundFloats, obj))
+                    elif isinstance(obj, float):
+                        return round(obj, 2)

schainpy/model/graphics/__init__.py 0 -1

             from .jroplot_voltage import *
             from .jroplot_spectra import *
             from .jroplot_heispectra import *
             from .jroplot_correlation import *
             from .jroplot_parameters import *
             from .jroplot_data import *
-            from .jroplotter import *

schainpy/model/graphics/jroplot_correlation.py +1 -1

             import os
             import datetime
             import numpy
             import copy
             from schainpy.model import *
             from .figure import Figure, isRealtime
-            class CorrelationPlot(Figure):
+            class CorrelationPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'corr'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 280
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = 1
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return None
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     lenfactor = factor.shape[1]
                     x = dataOut.getLagTRange(1)
                     y = dataOut.getHeiRange()
                     z = copy.copy(dataOut.data_corr[:,:,0,:])
                     for i in range(dataOut.data_corr.shape[0]):
                         z[i,:,:] = z[i,:,:]/factor[i,:]
                     zdB = numpy.abs(z)
                     avg = numpy.average(z, axis=1)
             #         avg = numpy.nanmean(z, axis=1)
             #         noise = dataOut.noise/factor
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Correlation"
                     xlabel = "Lag T (s)"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = dataOut.data_corr.shape[0]
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0
                         if zmax == None: zmax = 1
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d and %d: : %s" %(dataOut.pairsList[i][0],dataOut.pairsList[i][1] , str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[i,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
             #             if self.__showprofile:
             #                 axes = self.axesList[i*self.__nsubplots +1]
             #                 axes.pline(avgdB[i], y,
             #                         xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
             #                         xlabel='dB', ylabel='', title='',
             #                         ytick_visible=False,
             #                         grid='x')
             #
             #                 noiseline = numpy.repeat(noisedB[i], len(y))
             #                 axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)

schainpy/model/graphics/jroplot_data.py +72 -613

+            '''
+            New Plots Operations
+            @author: juan.espinoza@jro.igp.gob.pe
+            '''
-            import os
             import time
-            import glob
             import datetime
-            from multiprocessing import Process
-            import zmq
             import numpy
-            import matplotlib
-            import matplotlib.pyplot as plt
-            from matplotlib.patches import Polygon
-            from mpl_toolkits.axes_grid1 import make_axes_locatable
-            from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
-            from schainpy.model.proc.jroproc_base import Operation
+            from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.utils import log
-            jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
-            blu_values = matplotlib.pyplot.get_cmap(
-                'seismic_r', 20)(numpy.arange(20))[10:15]
-            ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
-                'jro', numpy.vstack((blu_values, jet_values)))
-            matplotlib.pyplot.register_cmap(cmap=ncmap)
-            CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis', 'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
             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
+                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 = 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)
-            def figpause(interval):
-                backend = plt.rcParams['backend']
-                if backend in matplotlib.rcsetup.interactive_bk:
-                    figManager = matplotlib._pylab_helpers.Gcf.get_active()
-                    if figManager is not None:
-                        canvas = figManager.canvas
-                        if canvas.figure.stale:
-                            canvas.draw()
-                        try:
-                            canvas.start_event_loop(interval)
-                        except:
-                            pass
-                        return
-            def popup(message):
-                '''
-                '''
-                fig = plt.figure(figsize=(12, 8), facecolor='r')
-                text = '\n'.join([s.strip() for s in message.split(':')])
-                fig.text(0.01, 0.5, text, ha='left', va='center', size='20', weight='heavy', color='w')
-                fig.show()
-                figpause(1000)
-            class PlotData(Operation, Process):
-                '''
-                Base class for Schain plotting operations
-                '''
-                CODE = 'Figure'
-                colormap = 'jro'
-                bgcolor = 'white'
-                CONFLATE = False
-                __missing = 1E30
-                __attrs__ = ['show', 'save', 'xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax',
-                             'zlimits', 'xlabel', 'ylabel', 'xaxis','cb_label', 'title',
-                             'colorbar', 'bgcolor', 'width', 'height', 'localtime', 'oneFigure',
-                             'showprofile', 'decimation', 'ftp']
-                def __init__(self, **kwargs):
-                    Operation.__init__(self, plot=True, **kwargs)
-                    Process.__init__(self)
-                    self.kwargs['code'] = self.CODE
-                    self.mp = False
-                    self.data = None
-                    self.isConfig = False
-                    self.figures = []
-                    self.axes = []
-                    self.cb_axes = []
-                    self.localtime = kwargs.pop('localtime', True)
-                    self.show = kwargs.get('show', True)
-                    self.save = kwargs.get('save', False)
-                    self.ftp = kwargs.get('ftp', False)
-                    self.colormap = kwargs.get('colormap', self.colormap)
-                    self.colormap_coh = kwargs.get('colormap_coh', 'jet')
-                    self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
-                    self.colormaps = kwargs.get('colormaps', None)
-                    self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
-                    self.showprofile = kwargs.get('showprofile', False)
-                    self.title = kwargs.get('wintitle', self.CODE.upper())
-                    self.cb_label = kwargs.get('cb_label', None)
-                    self.cb_labels = kwargs.get('cb_labels', None)
-                    self.labels = kwargs.get('labels', None)
-                    self.xaxis = kwargs.get('xaxis', 'frequency')
-                    self.zmin = kwargs.get('zmin', None)
-                    self.zmax = kwargs.get('zmax', None)
-                    self.zlimits = kwargs.get('zlimits', None)
-                    self.xmin = kwargs.get('xmin', None)
-                    self.xmax = kwargs.get('xmax', None)
-                    self.xrange = kwargs.get('xrange', 24)
-                    self.xscale = kwargs.get('xscale', None)
-                    self.ymin = kwargs.get('ymin', None)
-                    self.ymax = kwargs.get('ymax', None)
-                    self.yscale = kwargs.get('yscale', None)
-                    self.xlabel = kwargs.get('xlabel', None)
-                    self.decimation = kwargs.get('decimation', None)
-                    self.showSNR = kwargs.get('showSNR', False)
-                    self.oneFigure = kwargs.get('oneFigure', True)
-                    self.width = kwargs.get('width', None)
-                    self.height = kwargs.get('height', None)
-                    self.colorbar = kwargs.get('colorbar', True)
-                    self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
-                    self.channels = kwargs.get('channels', None)
-                    self.titles = kwargs.get('titles', [])
-                    self.polar = False
-                    self.grid = kwargs.get('grid', False)
-                def __fmtTime(self, x, pos):
-                    '''
-                    '''
-                    return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
-                def __setup(self):
-                    '''
-                    Common setup for all figures, here figures and axes are created
-                    '''
-                    if self.CODE not in self.data:
-                        raise ValueError(log.error('Missing data for {}'.format(self.CODE),
-                                                   self.name))
-                    self.setup()
-                    self.time_label = 'LT' if self.localtime else 'UTC'
-                    if self.data.localtime:
-                        self.getDateTime = datetime.datetime.fromtimestamp
-                    else:
-                        self.getDateTime = datetime.datetime.utcfromtimestamp
-                    if self.width is None:
-                        self.width = 8
-                    self.figures = []
-                    self.axes = []
-                    self.cb_axes = []
-                    self.pf_axes = []
-                    self.cmaps = []
-                    size = '15%' if self.ncols == 1 else '30%'
-                    pad = '4%' if self.ncols == 1 else '8%'
-                    if self.oneFigure:
-                        if self.height is None:
-                            self.height = 1.4 * self.nrows + 1
-                        fig = plt.figure(figsize=(self.width, self.height),
-                                         edgecolor='k',
-                                         facecolor='w')
-                        self.figures.append(fig)
-                        for n in range(self.nplots):
-                            ax = fig.add_subplot(self.nrows, self.ncols,
-                                                 n + 1, polar=self.polar)
-                            ax.tick_params(labelsize=8)
-                            ax.firsttime = True
-                            ax.index = 0
-                            ax.press = None
-                            self.axes.append(ax)
-                            if self.showprofile:
-                                cax = self.__add_axes(ax, size=size, pad=pad)
-                                cax.tick_params(labelsize=8)
-                                self.pf_axes.append(cax)
-                    else:
-                        if self.height is None:
-                            self.height = 3
-                        for n in range(self.nplots):
-                            fig = plt.figure(figsize=(self.width, self.height),
-                                             edgecolor='k',
-                                             facecolor='w')
-                            ax = fig.add_subplot(1, 1, 1, polar=self.polar)
-                            ax.tick_params(labelsize=8)
-                            ax.firsttime = True
-                            ax.index = 0
-                            ax.press = None
-                            self.figures.append(fig)
-                            self.axes.append(ax)
-                            if self.showprofile:
-                                cax = self.__add_axes(ax, size=size, pad=pad)
-                                cax.tick_params(labelsize=8)
-                                self.pf_axes.append(cax)
-                    for n in range(self.nrows):
-                        if self.colormaps is not None:
-                            cmap = plt.get_cmap(self.colormaps[n])
-                        else:
-                            cmap = plt.get_cmap(self.colormap)
-                        cmap.set_bad(self.bgcolor, 1.)
-                        self.cmaps.append(cmap)
-                    for fig in self.figures:
-                        fig.canvas.mpl_connect('key_press_event', self.OnKeyPress)
-                        fig.canvas.mpl_connect('scroll_event', self.OnBtnScroll)
-                        fig.canvas.mpl_connect('button_press_event', self.onBtnPress)
-                        fig.canvas.mpl_connect('motion_notify_event', self.onMotion)
-                        fig.canvas.mpl_connect('button_release_event', self.onBtnRelease)
-                        if self.show:
-                            fig.show()
-                def OnKeyPress(self, event):
-                    '''
-                    Event for pressing keys (up, down) change colormap
-                    '''
-                    ax = event.inaxes
-                    if ax in self.axes:
-                        if event.key == 'down':
-                            ax.index += 1
-                        elif event.key == 'up':
-                            ax.index -= 1
-                        if ax.index < 0:
-                            ax.index = len(CMAPS) - 1
-                        elif ax.index == len(CMAPS):
-                            ax.index = 0
-                        cmap = CMAPS[ax.index]
-                        ax.cbar.set_cmap(cmap)
-                        ax.cbar.draw_all()
-                        ax.plt.set_cmap(cmap)
-                        ax.cbar.patch.figure.canvas.draw()
-                        self.colormap = cmap.name
-                def OnBtnScroll(self, event):
-                    '''
-                    Event for scrolling, scale figure
-                    '''
-                    cb_ax = event.inaxes
-                    if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
-                        ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
-                        pt = ax.cbar.ax.bbox.get_points()[:, 1]
-                        nrm = ax.cbar.norm
-                        vmin, vmax, p0, p1, pS = (
-                            nrm.vmin, nrm.vmax, pt[0], pt[1], event.y)
-                        scale = 2 if event.step == 1 else 0.5
-                        point = vmin + (vmax - vmin) / (p1 - p0) * (pS - p0)
-                        ax.cbar.norm.vmin = point - scale * (point - vmin)
-                        ax.cbar.norm.vmax = point - scale * (point - vmax)
-                        ax.plt.set_norm(ax.cbar.norm)
-                        ax.cbar.draw_all()
-                        ax.cbar.patch.figure.canvas.draw()
-                def onBtnPress(self, event):
-                    '''
-                    Event for mouse button press
-                    '''
-                    cb_ax = event.inaxes
-                    if cb_ax is None:
-                        return
-                    if cb_ax in [ax.cbar.ax for ax in self.axes if ax.cbar]:
-                        cb_ax.press = event.x, event.y
-                    else:
-                        cb_ax.press = None
-                def onMotion(self, event):
-                    '''
-                    Event for move inside colorbar
-                    '''
-                    cb_ax = event.inaxes
-                    if cb_ax is None:
-                        return
-                    if cb_ax not in [ax.cbar.ax for ax in self.axes if ax.cbar]:
-                        return
-                    if cb_ax.press is None:
-                        return
-                    ax = [ax for ax in self.axes if cb_ax == ax.cbar.ax][0]
-                    xprev, yprev = cb_ax.press
-                    dx = event.x - xprev
-                    dy = event.y - yprev
-                    cb_ax.press = event.x, event.y
-                    scale = ax.cbar.norm.vmax - ax.cbar.norm.vmin
-                    perc = 0.03
-                    if event.button == 1:
-                        ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
-                        ax.cbar.norm.vmax -= (perc * scale) * numpy.sign(dy)
-                    elif event.button == 3:
-                        ax.cbar.norm.vmin -= (perc * scale) * numpy.sign(dy)
-                        ax.cbar.norm.vmax += (perc * scale) * numpy.sign(dy)
-                    ax.cbar.draw_all()
-                    ax.plt.set_norm(ax.cbar.norm)
-                    ax.cbar.patch.figure.canvas.draw()
-                def onBtnRelease(self, event):
-                    '''
-                    Event for mouse button release
-                    '''
-                    cb_ax = event.inaxes
-                    if cb_ax is not None:
-                        cb_ax.press = None
-                def __add_axes(self, ax, size='30%', pad='8%'):
-                    '''
-                    Add new axes to the given figure
-                    '''
-                    divider = make_axes_locatable(ax)
-                    nax = divider.new_horizontal(size=size, pad=pad)
-                    ax.figure.add_axes(nax)
-                    return nax
-                    self.setup()
-                def setup(self):
-                    '''
-                    This method should be implemented in the child class, the following
-                    attributes should be set:
-                    self.nrows: number of rows
-                    self.ncols: number of cols
-                    self.nplots: number of plots (channels or pairs)
-                    self.ylabel: label for Y axes
-                    self.titles: list of axes title
-                    '''
-                    raise NotImplementedError
-                def fill_gaps(self, x_buffer, y_buffer, z_buffer):
-                    '''
-                    Create a masked array for missing data
-                    '''
-                    if x_buffer.shape[0] < 2:
-                        return x_buffer, y_buffer, z_buffer
-                    deltas = x_buffer[1:] - x_buffer[0:-1]
-                    x_median = numpy.median(deltas)
-                    index = numpy.where(deltas > 5 * x_median)
-                    if len(index[0]) != 0:
-                        z_buffer[::, index[0], ::] = self.__missing
-                        z_buffer = numpy.ma.masked_inside(z_buffer,
-.99 * self.__missing,
-.01 * self.__missing)
-                    return x_buffer, y_buffer, z_buffer
-                def decimate(self):
-                    # dx = int(len(self.x)/self.__MAXNUMX) + 1
-                    dy = int(len(self.y) / self.decimation) + 1
-                    # x = self.x[::dx]
-                    x = self.x
-                    y = self.y[::dy]
-                    z = self.z[::, ::, ::dy]
-                    return x, y, z
-                def format(self):
+            class SpectraPlot(Plot):
-                    '''
-                    Set min and max values, labels, ticks and titles
-                    '''
-                    if self.xmin is None:
-                        xmin = self.min_time
-                    else:
-                        if self.xaxis is 'time':
-                            dt = self.getDateTime(self.min_time)
-                            xmin = (dt.replace(hour=int(self.xmin), minute=0, second=0) -
-                                    datetime.datetime(1970, 1, 1)).total_seconds()
-                            if self.data.localtime:
-                                xmin += time.timezone
-                        else:
-                            xmin = self.xmin
-                    if self.xmax is None:
-                        xmax = xmin + self.xrange * 60 * 60
-                    else:
-                        if self.xaxis is 'time':
-                            dt = self.getDateTime(self.max_time)
-                            xmax = (dt.replace(hour=int(self.xmax), minute=59, second=59) -
-                                    datetime.datetime(1970, 1, 1) + datetime.timedelta(seconds=1)).total_seconds()
-                            if self.data.localtime:
-                                xmax += time.timezone
-                        else:
-                            xmax = self.xmax
-                    ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
-                    ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
-                    Y = numpy.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000])
-                    i = 1 if numpy.where(abs(ymax-ymin) <= Y)[0][0] < 0 else numpy.where(abs(ymax-ymin) <= Y)[0][0]
-                    ystep = Y[i] / 10.
-                    if self.xaxis is not 'time':
-                        X = numpy.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000])/2.
-                        i = 1 if numpy.where(abs(xmax-xmin) <= X)[0][0] < 0 else numpy.where(abs(xmax-xmin) <= X)[0][0]
-                        xstep = X[i] / 10.
-                    for n, ax in enumerate(self.axes):
-                        if ax.firsttime:
-                            ax.set_facecolor(self.bgcolor)
-                            ax.yaxis.set_major_locator(MultipleLocator(ystep))
-                            if self.xscale:
-                                ax.xaxis.set_major_formatter(FuncFormatter(lambda x, pos: '{0:g}'.format(x*self.xscale)))
-                            if self.xscale:
-                                ax.yaxis.set_major_formatter(FuncFormatter(lambda x, pos: '{0:g}'.format(x*self.yscale)))
-                            if self.xaxis is 'time':
-                                ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
-                                ax.xaxis.set_major_locator(LinearLocator(9))
-                            else:
-                                ax.xaxis.set_major_locator(MultipleLocator(xstep))
-                            if self.xlabel is not None:
-                                ax.set_xlabel(self.xlabel)
-                            ax.set_ylabel(self.ylabel)
-                            ax.firsttime = False
-                            if self.showprofile:
-                                self.pf_axes[n].set_ylim(ymin, ymax)
-                                self.pf_axes[n].set_xlim(self.zmin, self.zmax)
-                                self.pf_axes[n].set_xlabel('dB')
-                                self.pf_axes[n].grid(b=True, axis='x')
-                                [tick.set_visible(False)
-                                 for tick in self.pf_axes[n].get_yticklabels()]
-                            if self.colorbar:
-                                ax.cbar = plt.colorbar(
-                                    ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
-                                ax.cbar.ax.tick_params(labelsize=8)
-                                ax.cbar.ax.press = None
-                                if self.cb_label:
-                                    ax.cbar.set_label(self.cb_label, size=8)
-                                elif self.cb_labels:
-                                    ax.cbar.set_label(self.cb_labels[n], size=8)
-                            else:
-                                ax.cbar = None
-                        if self.grid:
-                            ax.grid(True)
-                        if not self.polar:
-                            ax.set_xlim(xmin, xmax)
-                            ax.set_ylim(ymin, ymax)
-                            ax.set_title('{} {} {}'.format(
-                                self.titles[n],
-                                self.getDateTime(self.max_time).strftime('%Y-%m-%dT%H:%M:%S'),
-                                self.time_label),
-                                size=8)
-                        else:
-                            ax.set_title('{}'.format(self.titles[n]), size=8)
-                            ax.set_ylim(0, 90)
-                            ax.set_yticks(numpy.arange(0, 90, 20))
-                            ax.yaxis.labelpad = 40
-                def __plot(self):
-                    '''
-                    '''
-                    log.log('Plotting', self.name)
-                    try:
-                        self.plot()
-                        self.format()
-                    except Exception as e:
-                        log.warning('{} Plot could not be updated... check data'.format(self.CODE), self.name)
-                        log.error(str(e), '')
-                        return
-                    for n, fig in enumerate(self.figures):
-                        if self.nrows == 0 or self.nplots == 0:
-                            log.warning('No data', self.name)
-                            fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
-                            fig.canvas.manager.set_window_title(self.CODE)
-                            continue
-                        fig.tight_layout()
-                        fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
-                                                                             self.getDateTime(self.max_time).strftime('%Y/%m/%d')))
-                        fig.canvas.draw()
-                        if self.save and (self.data.ended or not self.data.buffering):
-                            if self.save_labels:
-                                labels = self.save_labels
-                            else:
-                                labels = list(range(self.nrows))
-                            if self.oneFigure:
-                                label = ''
-                            else:
-                                label = '-{}'.format(labels[n])
-                            figname = os.path.join(
-                                self.save,
-                                self.CODE,
-                                '{}{}_{}.png'.format(
-                                    self.CODE,
-                                    label,
-                                    self.getDateTime(self.saveTime).strftime(
-                                        '%Y%m%d_%H%M%S'),
-                            log.log('Saving figure: {}'.format(figname), self.name)
-                            if not os.path.isdir(os.path.dirname(figname)):
-                                os.makedirs(os.path.dirname(figname))
-                            fig.savefig(figname)
-                def plot(self):
-                    '''
-                    '''
-                    raise NotImplementedError
-                def run(self):
-                    log.log('Starting', self.name)
-                    context = zmq.Context()
-                    receiver = context.socket(zmq.SUB)
-                    receiver.setsockopt(zmq.SUBSCRIBE, '')
-                    receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
-                    if 'server' in self.kwargs['parent']:
-                        receiver.connect(
-                            'ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
-                    else:
-                        receiver.connect("ipc:///tmp/zmq.plots")
-                    while True:
-                        try:
-                            self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
-                            if self.data.localtime and self.localtime:
-                                self.times = self.data.times
-                            elif self.data.localtime and not self.localtime:
-                                self.times = self.data.times + time.timezone
-                            elif not self.data.localtime and self.localtime:
-                                self.times = self.data.times - time.timezone
-                            else:
-                                self.times = self.data.times
-                            self.min_time = self.times[0]
-                            self.max_time = self.times[-1]
-                            if self.isConfig is False:
-                                self.__setup()
-                                self.isConfig = True
-                            self.__plot()
-                        except zmq.Again as e:
-                            if self.data and self.data.ended:
-                                break
-                            log.log('Waiting for data...')
-                            if self.data:
-                                figpause(self.data.throttle)
-                            else:
-                                time.sleep(2)
-                def close(self):
-                    if self.data:
-                        self.__plot()
-            class PlotSpectraData(PlotData):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jro'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width += 0.8 * self.ncols
                     self.ylabel = 'Range [km]'
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'spc_mean':
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     z = self.data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = self.data['noise'][n][-1]
                         if self.CODE == 'spc_mean':
                             mean = self.data['mean'][n][-1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean = ax.plot(mean, y, color='k')[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(self.data['rti'][n][-1], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_mean':
                                 ax.plt_mean.set_data(mean, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
-                        self.saveTime = self.max_time
-            class PlotCrossSpectraData(PlotData):
+            class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nrows = len(self.data.pairs)
                     self.nplots = self.nrows * 4
                     self.width = 3.4 * self.ncols
                     self.height = 3 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.heights
                     self.y = y
                     spc = self.data['spc']
                     cspc = self.data['cspc']
                     for n in range(self.nrows):
                         noise = self.data['noise'][n][-1]
                         pair = self.data.pairs[n]
                         ax = self.axes[4 * n]
                         ax3 = self.axes[4 * n + 3]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
                             ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc[pair[0]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         ax = self.axes[4 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                         else:
                             ax.plt.set_array(spc[pair[1]].T.ravel())
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         ax = self.axes[4 * n + 2]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[4 * n + 3]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
-                        self.saveTime = self.max_time
-            class PlotSpectraMeanData(PlotSpectraData):
+            class SpectraMeanPlot(SpectraPlot):
                 '''
                 Plot for Spectra and Mean
                 '''
                 CODE = 'spc_mean'
                 colormap = 'jro'
-            class PlotRTIData(PlotData):
+            class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jro'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.cb_label = 'dB'
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def plot(self):
-                    self.x = self.times
+                    self.x = self.data.times
                     self.y = self.data.heights
                     self.z = self.data[self.CODE]
                     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.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     self.data['rti'][n][-1], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     self.data['noise'][n][-1], len(self.y)), self.y)
-                    self.saveTime = self.min_time
-            class PlotCOHData(PlotRTIData):
+            class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
-            class PlotPHASEData(PlotCOHData):
+            class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
-            class PlotNoiseData(PlotData):
+            class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.titles = ['Noise']
                     self.colorbar = False
                 def plot(self):
-                    x = self.times
+                    x = self.data.times
-                    xmin = self.min_time
+                    xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data[self.CODE]
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
                     self.ymin = numpy.nanmin(Y) - 5
                     self.ymax = numpy.nanmax(Y) + 5
-                    self.saveTime = self.min_time
-            class PlotSNRData(PlotRTIData):
+            class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
-            class PlotDOPData(PlotRTIData):
+            class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
-            class PlotSkyMapData(PlotData):
+            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.min_time).strftime('%y/%m/%d %H:%M:%S')
+                    dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
-                    dt2 = self.getDateTime(self.max_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
-                    self.saveTime = self.max_time
-            class PlotParamData(PlotRTIData):
+            class ParametersPlot(RTIPlot):
                 '''
                 Plot for data_param object
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape(self.CODE)[0]
                     self.nplots = self.nrows
                     if self.showSNR:
                         self.nrows += 1
                         self.nplots += 1
                     self.ylabel = 'Height [km]'
                     if not self.titles:
                         self.titles = self.data.parameters \
                             if self.data.parameters else ['Param {}'.format(x) for x in range(self.nrows)]
                         if self.showSNR:
                             self.titles.append('SNR')
                 def plot(self):
                     self.data.normalize_heights()
-                    self.x = self.times
+                    self.x = self.data.times
                     self.y = self.data.heights
                     if self.showSNR:
                         self.z = numpy.concatenate(
                             (self.data[self.CODE], self.data['snr'])
                         )
                     else:
                         self.z = self.data[self.CODE]
                     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]
                                                    )
-                    self.saveTime = self.min_time
-            class PlotOutputData(PlotParamData):
+            class OutputPlot(ParametersPlot):
                 '''
                 Plot data_output object
                 '''
                 CODE = 'output'
                 colormap = 'seismic'
-            class PlotPolarMapData(PlotData):
+            class PolarMapPlot(Plot):
                 '''
-                Plot for meteors detection data
+                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.xmin, self.xmax = float(
-                    self.ymin, self.ymax = float(km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
+                        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(0, self.data.meta['max_range'], data.shape[1])
+                        zeniths = numpy.linspace(
-                        if self.mode == 'E':
+, self.data.meta['max_range'], data.shape[1])
+                        if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.heights)+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, 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.heights)
                             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)),
+                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
-                                                   x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
+                                x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
-                                                    vmin=self.zmin,
+                                vmin=self.zmin,
-                                                    vmax=self.zmax,
+                                vmax=self.zmax,
-                                                    cmap=self.cmaps[n])
+                                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)),
+                            ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
-                                                   x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
+                                x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
-                                                    vmin=self.zmin,
+                                vmin=self.zmin,
-                                                    vmax=self.zmax,
+                                vmax=self.zmax,
-                                                    cmap=self.cmaps[n])
+                                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')
+                            ax.text(lon, lat, label.decode('utf8'), ha='center',
+                                    va='bottom', size='8', color='black')
                         # plot limites
-                        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))
+                            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.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]
-                    self.saveTime = self.max_time
-  No newline at end of file
+                    self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
+                    self.titles = ['{} {}'.format(
+                        self.data.parameters[x], title) for x in self.channels]

schainpy/model/graphics/jroplot_heispectra.py +2 -2

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from .figure import Figure, isRealtime
             from .plotting_codes import *
-            class SpectraHeisScope(Figure):
+            class SpectraHeisScope_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 230
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show = show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if dataOut.realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
             #        x = dataOut.heightList
                     c   =  3E8
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     #deberia cambiar para el caso de 1Mhz y 100KHz
                     x = numpy.arange(-1*dataOut.nHeights/2.,dataOut.nHeights/2.)*(c/(2*deltaHeight*dataOut.nHeights*1000))
                     #para 1Mhz descomentar la siguiente linea
                     #x= x/(10000.0)
             #        y = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
             #        y = y.real
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     datadB = 10.*numpy.log10(data)
                     y = datadB
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = ""
                     #para 1Mhz descomentar la siguiente linea
                     #xlabel = "Frequency x 10000"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         ychannel = y[i,:]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[channelIndexList[i]], numpy.max(ychannel), str_datetime)
                         axes = self.axesList[i]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, grid='both')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
-            class RTIfromSpectraHeis(Figure):
+            class RTIfromSpectraHeis_(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'rtinoise'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 820
                     self.HEIGHT = 200
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.xdata = None
                     self.ydata = None
                     self.figfile = None
                     self.PLOT_CODE = RTI_CODE
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show = show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if timerange != None:
                         self.timerange = timerange
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     data = dataOut.data_spc / factor
                     data = numpy.average(data,axis=1)
                     datadB = 10*numpy.log10(data)
             #        factor = dataOut.normFactor
             #        noise = dataOut.getNoise()/factor
             #        noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Intensity (dB)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.tmin, self.tmax = self.getTimeLim(x, xmin, xmax)
                         if ymin == None: ymin = numpy.nanmin(datadB)
                         if ymax == None: ymax = numpy.nanmax(datadB)
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                     self.setWinTitle(title)
             #        title = "RTI %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     title = "RTI - %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     legendlabels = ["channel %d"%idchannel for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = datadB[channelIndexList].reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, datadB[channelIndexList].reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.tmin, xmax=self.tmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='.', markersize=8, linestyle="solid", grid='both',
                                 XAxisAsTime=True
                                 )
                     self.draw()
                     update_figfile = False
                     if dataOut.ltctime >= self.tmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)

schainpy/model/graphics/jroplot_parameters.py +11 -11

             import os
             import datetime
             import numpy
             import inspect
             from .figure import Figure, isRealtime, isTimeInHourRange
             from .plotting_codes import *
             from schainpy.model.proc.jroproc_base import MPDecorator
             from schainpy.utils import log
-            class FitGauPlot(Figure):
+            class FitGauPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'fitgau'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None , GauSelector = 1):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
             #         if normFactor is None:
             #             factor = dataOut.normFactor
             #         else:
             #             factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.spc_range[0]
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.spc_range[1]
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.spc_range[2]
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.GauSPC[:,GauSelector,:,:] #GauSelector]    #dataOut.data_spc/factor
                     print('GausSPC', z[0,32,10:40])
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.spc_noise
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
-            class MomentsPlot(Figure):
+            class MomentsPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 280
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = MOMENTS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return None
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = dataOut.data_pre[channelIndexList,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     avgdB = 10*numpy.log10(avg)
                     noisedB = 10*numpy.log10(noise)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters"
                     xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(avgdB)*0.9
                         if zmax == None: zmax = numpy.nanmax(avgdB)*0.9
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[i], noisedB[i], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[i,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, cblabel='')
                                     #Mean Line
                         mean = dataOut.data_param[i, 1, :]
                         axes.addpline(mean, y, idline=0, color="black", linestyle="solid", lw=1)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[i], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[i], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
-            class SkyMapPlot(Figure):
+            class SkyMapPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'mmap'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
             #         self.WIDTH = 280
             #         self.HEIGHT = 250
                     self.WIDTH = 600
                     self.HEIGHT = 600
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = MSKYMAP_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH, #+ self.WIDTHPROF,
                                       heightplot = self.HEIGHT,# + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = 1,1
                     counter = 0
                     x = 0
                     y = 0
                     self.addAxes(1, 1, 0, 0, 1, 1, True)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         tmin=0, tmax=24, timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     arrayParameters = dataOut.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
                     x1 = [dataOut.ltctime, dataOut.ltctime]
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Parameters"
                     xlabel = "Zonal Zenith Angle (deg) "
                     ylabel = "Meridional Zenith Angle (deg)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if self.xmin is None and self.xmax is None:
                             self.xmin, self.xmax = self.getTimeLim(x1, tmin, tmax, timerange)
                         if timerange != None:
                             self.timerange = timerange
                         else:
                             self.timerange = self.xmax - self.xmin
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.firstdate = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     i = 0
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     axes = self.axesList[i*self.__nsubplots]
                     nevents = axes.x_buffer.shape[0] + x.shape[0]
                     title = "Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n" %(self.firstdate,str_datetime,nevents)
                     axes.polar(x, y,
                                 title=title, xlabel=xlabel, ylabel=ylabel,
                                 ticksize=9, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime >= self.xmax:
                         self.isConfigmagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                         axes.__firsttime = True
                         self.xmin += self.timerange
                         self.xmax += self.timerange
-            class WindProfilerPlot(Figure):
+            class WindProfilerPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'wind'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = WIND_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
                         counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='False',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         zmax_ver = None, zmin_ver = None, SNRmin = None, SNRmax = None,
                         timerange=None, SNRthresh = None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
             #         if timerange is not None:
             #             self.timerange = timerange
             #
             #         tmin = None
             #         tmax = None
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     z = dataOut.data_output.copy()
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR
                         SNRavg = numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         if SNRthresh == None: SNRthresh = -5.0
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     #thisDatetime = datetime.datetime.now()
                     title = wintitle + "Wind"
                     xlabel = ""
                     ylabel = "Height (km)"
                     update_figfile = False
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmax == None: zmax = numpy.nanmax(abs(z[list(range(2)),:]))
                         #if numpy.isnan(zmax): zmax = 50
                         if zmin == None: zmin = -zmax
                         if nplotsw == 3:
                             if zmax_ver == None: zmax_ver = numpy.nanmax(abs(z[2,:]))
                             if zmin_ver == None: zmin_ver = -zmax_ver
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal', 'Meridional', 'Vertical']
                     strCb = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
                     zmaxVector = [zmax, zmax, zmax_ver]
                     zminVector = [zmin, zmin, zmin_ver]
                     windFactor = [1,1,100]
                     for i in range(nplotsw):
                         title = "%s Wind: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))*windFactor[i]
                         #z1=numpy.ma.masked_where(z1==0.,z1)
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb[i], cbsize="1%", colormap="seismic" )
                     if dataOut.data_SNR is not None:
                         i += 1
                         title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.paramInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
             @MPDecorator
-            class ParametersPlot(Figure):
+            class ParametersPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'param'
                 nplots = None
                 nchan = None
                 def __init__(self):#, **kwargs):
                     Figure.__init__(self)#, **kwargs)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, paramIndex = 0, colormap="jet",
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, timerange=None,
                         showSNR=False, SNRthresh = -numpy.inf, SNRmin=None, SNRmax=None,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if HEIGHT is not None:
                         self.HEIGHT = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = list(range(dataOut.data_param.shape[0]))
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.getHeiRange()
                     if dataOut.data_param.ndim == 3:
                         z = dataOut.data_param[channelIndexList,paramIndex,:]
                     else:
                         z = dataOut.data_param[channelIndexList,:]
                     if showSNR:
                         #SNR data
                         SNRarray = dataOut.data_SNR[channelIndexList,:]
                         SNRdB = 10*numpy.log10(SNRarray)
                         ind = numpy.where(SNRdB < SNRthresh)
                         z[ind] = numpy.nan
                     thisDatetime = dataOut.datatime
             #         thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nchan = len(channelIndexList)
                         self.nchan = nchan
                         self.plotFact = 1
                         nplots = nchan
                         if showSNR:
                             nplots = nchan*2
                             self.plotFact = 2
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nchan):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.plotFact]
                         z1 = z[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%",colormap=colormap)
                         if showSNR:
                             title = "Channel %d SNR: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             axes = self.axesList[i*self.plotFact + 1]
                             SNRdB1 = SNRdB[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, SNRdB1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%",colormap='jet')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
-            class Parameters1Plot(Figure):
+            class Parameters1Plot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = PARMS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=False,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,timerange=None,
                         parameterIndex = None, onlyPositive = False,
                         SNRthresh = -numpy.inf, SNR = True, SNRmin = None, SNRmax = None, onlySNR = False,
                         DOP = True,
                         zlabel = "", parameterName = "", parameterObject = "data_param",
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     #print inspect.getargspec(self.run).args
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     data_param = getattr(dataOut, parameterObject)
                     if channelList == None:
                         channelIndexList = numpy.arange(data_param.shape[0])
                     else:
                         channelIndexList = numpy.array(channelList)
                     nchan = len(channelIndexList) #Number of channels being plotted
                     if nchan < 1:
                         return
                     nGraphsByChannel = 0
                     if SNR:
                         nGraphsByChannel += 1
                     if DOP:
                         nGraphsByChannel += 1
                     if nGraphsByChannel < 1:
                         return
                     nplots = nGraphsByChannel*nchan
                     if timerange is not None:
                         self.timerange = timerange
                     #tmin = None
                     #tmax = None
                     if parameterIndex == None:
                         parameterIndex = 1
                     x = dataOut.getTimeRange1(dataOut.paramInterval)
                     y = dataOut.heightList
                     if dataOut.data_param.ndim == 3:
                         z = dataOut.data_param[channelIndexList,parameterIndex,:]
                     else:
                         z = dataOut.data_param[channelIndexList,:]
                     if dataOut.data_SNR is not None:
                         if dataOut.data_SNR.ndim == 2:
                             SNRavg = numpy.average(dataOut.data_SNR, axis=0)
                         else:
                             SNRavg = dataOut.data_SNR
                         SNRdB = 10*numpy.log10(SNRavg)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Parameters Plot" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     if onlyPositive:
                         colormap = "jet"
                         zmin = 0
                     else: colormap = "RdBu_r"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.nanmin(z)
                         if zmax == None: zmax = numpy.nanmax(z)
                         if SNR:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     for i in range(nchan):
                         if (SNR and not onlySNR): j = 2*i
                         else: j = i
                         j = nGraphsByChannel*i
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         if not onlySNR:
                             axes = self.axesList[j*self.__nsubplots]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                     ticksize=9, cblabel=zlabel, cbsize="1%")
                         if DOP:
                             title = "%s Channel %d: %s" %(parameterName, channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                             if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                                 title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                             axes = self.axesList[j]
                             z1 = z[i,:].reshape((1,-1))
                             axes.pcolorbuffer(x, y, z1,
                                         xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                         xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap=colormap,
                                         ticksize=9, cblabel=zlabel, cbsize="1%")
                     if SNR:
                         title = "Channel %d Signal Noise Ratio (SNR): %s" %(channelIndexList[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[(j)*self.__nsubplots]
                         if not onlySNR:
                             axes = self.axesList[(j + 1)*self.__nsubplots]
                         axes = self.axesList[(j + nGraphsByChannel-1)]
                         z1 = SNRdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,colormap="jet",
                                 ticksize=9, cblabel=zlabel, cbsize="1%")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=False)
                     return dataOut
-            class SpectralFittingPlot(Figure):
+            class SpectralFittingPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'prm'
                 N = None
                 ippSeconds = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = SPECFIT_CODE
                     self.WIDTH = 450
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=False, show=True):
                     showprofile = False
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 5
                     colspan = 4
                     if showprofile:
                         ncolspan = 5
                         colspan = 4
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, cutHeight=None, fit=False, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if cutHeight==None:
                         h=270
                     heightindex = numpy.abs(cutHeight - dataOut.heightList).argmin()
                     cutHeight = dataOut.heightList[heightindex]
                     factor = dataOut.normFactor
                     x = dataOut.abscissaList[:-1]
                     #y = dataOut.getHeiRange()
                     z = dataOut.data_pre[:,:,heightindex]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     listChannels = z.shape[0]
                     #Reconstruct Function
                     if fit==True:
                         groupArray = dataOut.groupList
                         listChannels = groupArray.reshape((groupArray.size))
                         listChannels.sort()
                         spcFitLine = numpy.zeros(z.shape)
                         constants = dataOut.constants
                         nGroups = groupArray.shape[0]
                         nChannels = groupArray.shape[1]
                         nProfiles = z.shape[1]
                         for f in range(nGroups):
                             groupChann = groupArray[f,:]
                             p = dataOut.data_param[f,:,heightindex]
             #                 p = numpy.array([ 89.343967,0.14036615,0.17086219,18.89835291,1.58388365,1.55099167])
                             fitLineAux = dataOut.library.modelFunction(p, constants)*nProfiles
                             fitLineAux = fitLineAux.reshape((nChannels,nProfiles))
                             spcFitLine[groupChann,:] = fitLineAux
             #             spcFitLine = spcFitLine/factor
                         z = z[listChannels,:]
                         spcFitLine = spcFitLine[listChannels,:]
                         spcFitLinedB = 10*numpy.log10(spcFitLine)
                     zdB = 10*numpy.log10(z)
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Doppler Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Velocity (m/s)"
                     ylabel = "Spectrum"
                     if not self.isConfig:
                         nplots = listChannels.size
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)+2
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
             #             title = "Channel %d: %4.2fdB" %(dataOut.channelList[i]+1, noisedB[i])
                         title = "Height %4.1f km\nChannel %d:" %(cutHeight, listChannels[i])
                         axes = self.axesList[i*self.__nsubplots]
                         if fit == False:
                             axes.pline(x, zdB[i,:],
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title
                                         )
                         if fit == True:
                             fitline=spcFitLinedB[i,:]
                             y=numpy.vstack([zdB[i,:],fitline] )
                             legendlabels=['Data','Fitting']
                             axes.pmultilineyaxis(x, y,
                                         xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                         xlabel=xlabel, ylabel=ylabel, title=title,
                                         legendlabels=legendlabels, marker=None,
                                         linestyle='solid', grid='both')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
-            class EWDriftsPlot(Figure):
+            class EWDriftsPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'drift'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 150
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = EWDRIFT_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         if counter >= self.nplots:
                             break
                         self.addAxes(nrow, ncol*ncolspan, y, 0, colspan, 1)
                         counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         zmaxVertical = None, zminVertical = None, zmaxZonal = None, zminZonal = None,
                         timerange=None, SNRthresh = -numpy.inf, SNRmin = None, SNRmax = None, SNR_1 = False,
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if timerange is not None:
                         self.timerange = timerange
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
             #         y = dataOut.heightList
                     y = dataOut.heightList
                     z = dataOut.data_output
                     nplots = z.shape[0]    #Number of wind dimensions estimated
                     nplotsw = nplots
                     #If there is a SNR function defined
                     if dataOut.data_SNR is not None:
                         nplots += 1
                         SNR = dataOut.data_SNR
                         if SNR_1:
                             SNR += 1
                         SNRavg = numpy.average(SNR, axis=0)
                         SNRdB = 10*numpy.log10(SNR)
                         SNRavgdB = 10*numpy.log10(SNRavg)
                         ind = numpy.where(SNRavg < 10**(SNRthresh/10))[0]
                         for i in range(nplotsw):
                             z[i,ind] = numpy.nan
                     showprofile = False
             #        thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(x[1])
                     title = wintitle + " EW Drifts"
                     xlabel = ""
                     ylabel = "Height (Km)"
                     if not self.isConfig:
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmaxZonal == None: zmaxZonal = numpy.nanmax(abs(z[0,:]))
                         if zminZonal == None: zminZonal = -zmaxZonal
                         if zmaxVertical == None: zmaxVertical = numpy.nanmax(abs(z[1,:]))
                         if zminVertical == None: zminVertical = -zmaxVertical
                         if dataOut.data_SNR is not None:
                             if SNRmin == None:  SNRmin = numpy.nanmin(SNRavgdB)
                             if SNRmax == None:  SNRmax = numpy.nanmax(SNRavgdB)
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                     self.setWinTitle(title)
                     if ((self.xmax - x[1]) < (x[1]-x[0])):
                         x[1] = self.xmax
                     strWind = ['Zonal','Vertical']
                     strCb = 'Velocity (m/s)'
                     zmaxVector = [zmaxZonal, zmaxVertical]
                     zminVector = [zminZonal, zminVertical]
                     for i in range(nplotsw):
                         title = "%s Drifts: %s" %(strWind[i], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         z1 = z[i,:].reshape((1,-1))
                         axes.pcolorbuffer(x, y, z1,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zminVector[i], zmax=zmaxVector[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel=strCb, cbsize="1%", colormap="RdBu_r")
                     if dataOut.data_SNR is not None:
                         i += 1
                         if SNR_1:
                             title = "Signal Noise Ratio + 1 (SNR+1): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         else:
                             title = "Signal Noise Ratio (SNR): %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots]
                         SNRavgdB = SNRavgdB.reshape((1,-1))
                         axes.pcolorbuffer(x, y, SNRavgdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=SNRmin, zmax=SNRmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap="jet")
                     self.draw()
                     if x[1] >= self.axesList[0].xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         self.figfile = None
-            class PhasePlot(Figure):
+            class PhasePlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'mphase'
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 600
                     self.HEIGHT = 300
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = MPHASE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     tmin = None
                     tmax = None
                     x = dataOut.getTimeRange1(dataOut.outputInterval)
                     y = dataOut.getHeiRange()
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     title = wintitle + " Phase of Beacon Signal" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase"
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = dataOut.data_output
                     update_figfile = False
                     if not self.isConfig:
                         self.nplots = phase_beacon.size
                         self.setup(id=id,
                                    nplots=self.nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange is not None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(phase_beacon) - 10.0
                         if ymax == None: ymax = numpy.nanmax(phase_beacon) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         update_figfile = True
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Offset %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["phase %d"%(chan) for chan in numpy.arange(self.nplots)]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     self.save(figpath=figpath,
                       figfile=figfile,
                       save=save,
                       ftp=ftp,
                       wr_period=wr_period,
                       thisDatetime=thisDatetime,
                       update_figfile=update_figfile)
                     if dataOut.ltctime + dataOut.outputInterval >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
-            class NSMeteorDetection1Plot(Figure):
+            class NSMeteorDetection1Plot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #SEPARAR EN DOS PLOTS
                     nParam = dataOut.data_param.shape[1] - 3
                     utctime = dataOut.data_param[0,0]
                     tmet = dataOut.data_param[:,1].astype(int)
                     hmet = dataOut.data_param[:,2].astype(int)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.zeros((nParam, y.size, x.size - 1))
                     z[:,:] = numpy.nan
                     z[:,hmet,tmet] = dataOut.data_param[:,3:].T
                     z[0,:,:] = 10*numpy.log10(z[0,:,:])
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         pairsList = dataOut.groupList
                         self.nPairs = len(dataOut.groupList)
                         zminList = [SNRmin, vmin, cmin] + [pmin]*self.nPairs
                         zmaxList = [SNRmax, vmax, cmax] + [pmax]*self.nPairs
                         titleList = ["SNR","Radial Velocity","Coherence"]
                         cmapList = ["jet","RdBu_r","jet"]
                         for i in range(self.nPairs):
                             strAux1 = "Phase Difference "+ str(pairsList[i][0]) + str(pairsList[i][1])
                             titleList = titleList + [strAux1]
                             cmapList = cmapList + ["RdBu_r"]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(nParam):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
-            class NSMeteorDetection2Plot(Figure):
+            class NSMeteorDetection2Plot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'nsm'
                 zminList = None
                 zmaxList = None
                 cmapList = None
                 titleList = None
                 nPairs = None
                 nChannels = None
                 nParam = None
                 def __init__(self, **kwargs):
                     Figure.__init__(self, **kwargs)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 750
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = 3
                     nrow = int(numpy.ceil(self.nplots/3.0))
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show=True):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, SNRmin=None, SNRmax=None,
                         vmin=None, vmax=None, wmin=None, wmax=None, mode = 'SA',
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency"):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     #Rebuild matrix
                     utctime = dataOut.data_param[0,0]
                     cmet = dataOut.data_param[:,1].astype(int)
                     tmet = dataOut.data_param[:,2].astype(int)
                     hmet = dataOut.data_param[:,3].astype(int)
                     nParam = 3
                     nChan = len(dataOut.groupList)
                     x = dataOut.abscissaList
                     y = dataOut.heightList
                     z = numpy.full((nChan, nParam, y.size, x.size - 1),numpy.nan)
                     z[cmet,:,hmet,tmet] = dataOut.data_param[:,4:]
                     z[:,0,:,:] = 10*numpy.log10(z[:,0,:,:]) #logarithmic scale
                     z = numpy.reshape(z, (nChan*nParam, y.size, x.size-1))
                     xlabel = "Time (s)"
                     ylabel = "Range (km)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.ltctime)
                     if not self.isConfig:
                         nplots = nParam*nChan
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin is None: xmin = numpy.nanmin(x)
                         if xmax is None: xmax = numpy.nanmax(x)
                         if ymin is None: ymin = numpy.nanmin(y)
                         if ymax is None: ymax = numpy.nanmax(y)
                         if SNRmin is None: SNRmin = numpy.nanmin(z[0,:])
                         if SNRmax is None: SNRmax = numpy.nanmax(z[0,:])
                         if vmax is None: vmax = numpy.nanmax(numpy.abs(z[1,:]))
                         if vmin is None: vmin = -vmax
                         if wmin is None: wmin = 0
                         if wmax is None: wmax = 50
                         self.nChannels = nChan
                         zminList = []
                         zmaxList = []
                         titleList = []
                         cmapList = []
                         for i in range(self.nChannels):
                             strAux1 = "SNR Channel "+ str(i)
                             strAux2 = "Radial Velocity Channel "+ str(i)
                             strAux3 = "Spectral Width Channel "+ str(i)
                             titleList = titleList + [strAux1,strAux2,strAux3]
                             cmapList = cmapList + ["jet","RdBu_r","jet"]
                             zminList = zminList + [SNRmin,vmin,wmin]
                             zmaxList = zmaxList + [SNRmax,vmax,wmax]
                         self.zminList = zminList
                         self.zmaxList = zmaxList
                         self.cmapList = cmapList
                         self.titleList = titleList
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                     for i in range(self.nplots):
                         title = self.titleList[i] + ": " +str_datetime
                         axes = self.axesList[i]
                         axes.pcolor(x, y, z[i,:].T,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=self.zminList[i], zmax=self.zmaxList[i],
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=self.cmapList[i],ticksize=9, cblabel='')
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
   No newline at end of file

schainpy/model/graphics/jroplot_spectra.py +8 -8

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from .figure import Figure, isRealtime, isTimeInHourRange
             from .plotting_codes import *
             from schainpy.model.proc.jroproc_base import MPDecorator
             from schainpy.utils import log
             @MPDecorator
-            class SpectraPlot(Figure):
+            class SpectraPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = SPEC_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.__xfilter_ena = False
                     self.__yfilter_ena = False
                 def getSubplots(self):
                     ncol = int(numpy.sqrt(self.nplots)+0.9)
                     nrow = int(self.nplots*1./ncol + 0.9)
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 3
                         colspan = 2
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile=True,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, realtime=False,
                         xaxis="frequency", colormap='jet', normFactor=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if realtime:
                         if not(isRealtime(utcdatatime = dataOut.utctime)):
                             print('Skipping this plot function')
                             return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList" %channel)
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     zdB = 10*numpy.log10(z)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10*numpy.log10(avg)
                     noise = dataOut.getNoise()/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Spectra"
                     if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                         title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Channel %d: %4.2fdB: %s" %(dataOut.channelList[index], noisedB[index], str_datetime)
                         if len(dataOut.beam.codeList) != 0:
                             title = "Ch%d:%4.2fdB,%2.2f,%2.2f:%s" %(dataOut.channelList[index], noisedB[index], dataOut.beam.azimuthList[index], dataOut.beam.zenithList[index], str_datetime)
                         axes = self.axesList[i*self.__nsubplots]
                         axes.pcolor(x, y, zdB[index,:,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, colormap=colormap,
                                     ticksize=9, cblabel='')
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index,:], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                             noiseline = numpy.repeat(noisedB[index], len(y))
                             axes.addpline(noiseline, y, idline=1, color="black", linestyle="dashed", lw=2)
                     self.draw()
                     if figfile == None:
                         str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         name = str_datetime
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             name = name + '_az' + '_%2.2f'%(dataOut.azimuth) + '_zn' + '_%2.2f'%(dataOut.zenith)
                         figfile = self.getFilename(name)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
-            class CrossSpectraPlot(Figure):
+            class CrossSpectraPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTH = None
                 HEIGHT = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cspc'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 4
                     self.counter_imagwr = 0
                     self.WIDTH = 250
                     self.HEIGHT = 250
                     self.WIDTHPROF = 0
                     self.HEIGHTPROF = 0
                     self.PLOT_CODE = CROSS_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                 def getSubplots(self):
                     ncol = 4
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", pairsList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         coh_min=None, coh_max=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         power_cmap='jet', coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None,
                         xaxis='frequency'):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %str(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if not pairsIndexList:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     x = dataOut.getVelRange(1)
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc[:,:,:]/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     noise = dataOut.noise/factor
                     zdB = 10*numpy.log10(z)
                     noisedB = 10*numpy.log10(noise)
                     if coh_min == None:
                         coh_min = 0.0
                     if coh_max == None:
                         coh_max = 1.0
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     #thisDatetime = dataOut.datatime
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Cross-Spectra: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
             #         xlabel = "Velocity (m/s)"
                     ylabel = "Range (Km)"
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange(1)/1000.
                         xlabel = "Frequency (kHz)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange(1)
                         xlabel = "Time (ms)"
                     else:
                         x = dataOut.getVelRange(1)
                         xlabel = "Velocity (m/s)"
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=False,
                                    show=show)
                         avg = numpy.abs(numpy.average(z, axis=1))
                         avgdB = 10*numpy.log10(avg)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         chan_index0 = dataOut.channelList.index(pair[0])
                         chan_index1 = dataOut.channelList.index(pair[1])
                         str_datetime = '%s %s'%(thisDatetime.strftime("%Y/%m/%d"),thisDatetime.strftime("%H:%M:%S"))
                         title = "Ch%d: %4.2fdB: %s" %(pair[0], noisedB[chan_index0], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index0,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         title = "Ch%d: %4.2fdB: %s" %(pair[1], noisedB[chan_index1], str_datetime)
                         zdB = 10.*numpy.log10(dataOut.data_spc[chan_index1,:,:]/factor)
                         axes0 = self.axesList[i*self.__nsubplots+1]
                         axes0.pcolor(x, y, zdB,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=power_cmap, cblabel='')
                         coherenceComplex = dataOut.data_cspc[pairsIndexList[i],:,:]/numpy.sqrt(dataOut.data_spc[chan_index0,:,:]*dataOut.data_spc[chan_index1,:,:])
                         coherence = numpy.abs(coherenceComplex)
             #            phase = numpy.arctan(-1*coherenceComplex.imag/coherenceComplex.real)*180/numpy.pi
                         phase = numpy.arctan2(coherenceComplex.imag, coherenceComplex.real)*180/numpy.pi
                         title = "Coherence Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+2]
                         axes0.pcolor(x, y, coherence,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=coh_min, zmax=coh_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=coherence_cmap, cblabel='')
                         title = "Phase Ch%d * Ch%d" %(pair[0], pair[1])
                         axes0 = self.axesList[i*self.__nsubplots+3]
                         axes0.pcolor(x, y, phase,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title,
                                     ticksize=9, colormap=phase_cmap, cblabel='')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
-            class RTIPlot(Figure):
+            class RTIPlot_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'rti'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = None
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = RTI_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.tmin = None
                     self.tmax = None
                     self.xmin = None
                     self.xmax = None
                     self.figfile = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             if counter >= self.nplots:
                                 break
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                             counter += 1
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, colormap='jet',
                         save=False, figpath='./', lastone=0,figfile=None, ftp=False, wr_period=1, show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, normFactor=None, HEIGHT=None):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         showProfile     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                         zmin            :    None,
                         zmax            :    None
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     #colormap = kwargs.get('colormap', 'jet')
                     if HEIGHT is not None:
                         self.HEIGHT  = HEIGHT
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     if normFactor is None:
                         factor = dataOut.normFactor
                     else:
                         factor = normFactor
                     #factor = dataOut.normFactor
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     avg = numpy.average(z, axis=1)
                     avgdB = 10.*numpy.log10(avg)
                     # avgdB = dataOut.getPower()
                     thisDatetime = dataOut.datatime
                     #thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " RTI" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if self.xmax is not None and dataOut.ltctime >= self.xmax: #yong
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         noise = dataOut.noise/factor
                         noisedB = 10*numpy.log10(noise)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = numpy.floor(numpy.nanmin(noisedB)) - 3
                         if zmax == None: zmax = numpy.ceil(numpy.nanmax(avgdB)) + 3
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         index = channelIndexList[i]
                         title = "Channel %d: %s" %(dataOut.channelList[index], thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                         if ((dataOut.azimuth!=None) and (dataOut.zenith!=None)):
                             title = title + '_' + 'azimuth,zenith=%2.2f,%2.2f'%(dataOut.azimuth, dataOut.zenith)
                         axes = self.axesList[i*self.__nsubplots]
                         zdB = avgdB[index].reshape((1,-1))
                         axes.pcolorbuffer(x, y, zdB,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', cbsize="1%", colormap=colormap)
                         if self.__showprofile:
                             axes = self.axesList[i*self.__nsubplots +1]
                             axes.pline(avgdB[index], y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='dB', ylabel='', title='',
                                     ytick_visible=False,
                                     grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
-            class CoherenceMap(Figure):
+            class CoherenceMap_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'cmap'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 2*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.WIDTH = 800
                     self.HEIGHT = 180
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.counter_imagwr = 0
                     self.PLOT_CODE = COH_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.counter_imagwr = 0
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = self.nplots*2
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     if showprofile:
                         ncolspan = 7
                         colspan = 6
                         self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH + self.WIDTHPROF,
                                       heightplot = self.HEIGHT + self.HEIGHTPROF,
                                       show=True)
                     nrow, ncol = self.getSubplots()
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                             if showprofile:
                                 self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan+colspan, 1, 1)
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None,
                         timerange=None, phase_min=None, phase_max=None,
                         save=False, figpath='./', figfile=None, ftp=False, wr_period=1,
                         coherence_cmap='jet', phase_cmap='RdBu_r', show=True,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
                     if len(pairsIndexList) > 4:
                         pairsIndexList = pairsIndexList[0:4]
                     if phase_min == None:
                         phase_min = -180
                     if phase_max == None:
                         phase_max = 180
                     x = dataOut.getTimeRange()
                     y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " CoherenceMap" #: %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Range (Km)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if zmin == None: zmin = 0.
                         if zmax == None: zmax = 1.
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         update_figfile = True
                     self.setWinTitle(title)
                     for i in range(self.nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i],:,:],axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0],:,:],axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1],:,:],axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         coherence = numpy.abs(avgcoherenceComplex)
                         z = coherence.reshape((1,-1))
                         counter = 0
                         title = "Coherence Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=zmin, zmax=zmax,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=coherence_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(coherence, y,
                                     xmin=zmin, xmax=zmax, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=5,
                                     grid='x')
                         counter += 1
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         z = phase.reshape((1,-1))
                         title = "Phase Ch%d * Ch%d: %s" %(pair[0], pair[1], thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                         axes = self.axesList[i*self.__nsubplots*2 + counter]
                         axes.pcolorbuffer(x, y, z,
                                     xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax, zmin=phase_min, zmax=phase_max,
                                     xlabel=xlabel, ylabel=ylabel, title=title, rti=True, XAxisAsTime=True,
                                     ticksize=9, cblabel='', colormap=phase_cmap, cbsize="1%")
                         if self.__showprofile:
                             counter += 1
                             axes = self.axesList[i*self.__nsubplots*2 + counter]
                             axes.pline(phase, y,
                                     xmin=phase_min, xmax=phase_max, ymin=ymin, ymax=ymax,
                                     xlabel='', ylabel='', title='', ticksize=7,
                                     ytick_visible=False, nxticks=4,
                                     grid='x')
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut
             @MPDecorator
-            class PowerProfilePlot(Figure):
+            class PowerProfilePlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spcprofile'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 300
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None):
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     #for voltage
                     if dataOut.type == 'Voltage':
                         x = dataOut.data[channelIndexList,:] * numpy.conjugate(dataOut.data[channelIndexList,:])
                         x = x.real
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                     #for spectra
                     if dataOut.type == 'Spectra':
                         x = dataOut.data_spc[channelIndexList,:,:]/factor
                         x = numpy.where(numpy.isfinite(x), x, numpy.NAN)
                         x = numpy.average(x, axis=1)
                     xdB = 10*numpy.log10(x)
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Power Profile %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "dB"
                     ylabel = "Range (Km)"
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if ymin == None: ymin = numpy.nanmin(y)
                         if ymax == None: ymax = numpy.nanmax(y)
                         if xmin == None: xmin = numpy.nanmin(xdB)*0.9
                         if xmax == None: xmax = numpy.nanmax(xdB)*1.1
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Power Profile: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["channel %d"%x for x in channelList]
                     axes.pmultiline(xdB, y,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
-            class SpectraCutPlot(Figure):
+            class SpectraCutPlot_(Figure):
                 isConfig = None
                 __nsubplots = None
                 WIDTHPROF = None
                 HEIGHTPROF = None
                 PREFIX = 'spc_cut'
                 def __init__(self):
                     Figure.__init__(self)
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.PLOT_CODE = POWER_CODE
                     self.WIDTH = 700
                     self.HEIGHT = 500
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     ncolspan = 1
                     colspan = 1
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH,
                                       heightplot = self.HEIGHT,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     counter = 0
                     for y in range(nrow):
                         for x in range(ncol):
                             self.addAxes(nrow, ncol*ncolspan, y, x*ncolspan, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         save=False, figpath='./', figfile=None, show=True,
                         ftp=False, wr_period=1, server=None,
                         folder=None, username=None, password=None,
                         xaxis="frequency"):
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     factor = dataOut.normFactor
                     y = dataOut.getHeiRange()
                     z = dataOut.data_spc/factor
                     z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                     hei_index = numpy.arange(25)*3 + 20
                     if xaxis == "frequency":
                         x = dataOut.getFreqRange()/1000.
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Frequency (kHz)"
                         ylabel = "Power (dB)"
                     elif xaxis == "time":
                         x = dataOut.getAcfRange()
                         zdB = z[0,:,hei_index]
                         xlabel = "Time (ms)"
                         ylabel = "ACF"
                     else:
                         x = dataOut.getVelRange()
                         zdB = 10*numpy.log10(z[0,:,hei_index])
                         xlabel = "Velocity (m/s)"
                         ylabel = "Power (dB)"
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     title = wintitle + " Range Cuts %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)*0.9
                         if xmax == None: xmax = numpy.nanmax(x)*1.1
                         if ymin == None: ymin = numpy.nanmin(zdB)
                         if ymax == None: ymax = numpy.nanmax(zdB)
                         self.isConfig = True
                     self.setWinTitle(title)
                     title = "Spectra Cuts: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     axes = self.axesList[0]
                     legendlabels = ["Range = %dKm" %y[i] for i in hei_index]
                     axes.pmultilineyaxis( x, zdB,
                             xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                             xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels,
                             ytick_visible=True, nxticks=5,
                             grid='x')
                     self.draw()
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut
             @MPDecorator
-            class Noise(Figure):
+            class Noise_(Figure):
                 isConfig = None
                 __nsubplots = None
                 PREFIX = 'noise'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = NOISE_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def openfile(self, filename):
                     dirname = os.path.dirname(filename)
                     if not os.path.exists(dirname):
                         os.mkdir(dirname)
                     f = open(filename,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Noise \n')
                     f.write('DD MM YYYY  HH MM SS   Channel0    Channel1    Channel2    Channel3\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     data_msg = ''
                     for i in range(len(data)):
                         data_msg += str(data[i]) + '  '
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   ' + data_msg + '\n')
                     f.close()
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def run(self, dataOut, id, wintitle="", channelList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                         channelList = dataOut.channelList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     factor = dataOut.normFactor
                     noise = dataOut.noise[channelIndexList]/factor
                     noisedB = 10*numpy.log10(noise)
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Noise" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = ""
                     ylabel = "Intensity (dB)"
                     update_figfile = False
                     if not self.isConfig:
                         nplots = 1
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = numpy.floor(numpy.nanmin(noisedB)) - 10.0
                         if ymax == None: ymax = numpy.nanmax(noisedB) + 10.0
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         noise_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_noise = os.path.join(figpath,noise_file)
                     self.setWinTitle(title)
                     title = "Noise %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["channel %d"%(idchannel) for idchannel in channelList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = noisedB.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, noisedB.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     #store data beacon phase
                     if save:
                         self.save_data(self.filename_noise, noisedB, thisDatetime)
                     return dataOut
             @MPDecorator
-            class BeaconPhase(Figure):
+            class BeaconPhase_(Figure):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Figure.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
             #         if len(pairsIndexList) > 4:
             #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     #y = dataOut.getHeiRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         #print "Phase %d%d" %(pair[0], pair[1])
                         #print phase[dataOut.beacon_heiIndexList]
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut

schainpy/model/graphics/jroplot_voltage.py +1 -1

             '''
             Created on Jul 9, 2014
             @author: roj-idl71
             '''
             import os
             import datetime
             import numpy
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator  #YONG
             from schainpy.utils import log
             from .figure import Figure
             @MPDecorator
-            class Scope(Figure):
+            class Scope_(Figure):
                 isConfig = None
                 def __init__(self):#, **kwargs):          #YONG
                     Figure.__init__(self)#, **kwargs)
                     self.isConfig = False
                     self.WIDTH = 300
                     self.HEIGHT = 200
                     self.counter_imagwr = 0
                 def getSubplots(self):
                     nrow = self.nplots
                     ncol = 3
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, show):
                     self.nplots = nplots
                     self.createFigure(id=id,
                                       wintitle=wintitle,
                                       show=show)
                     nrow,ncol = self.getSubplots()
                     colspan = 3
                     rowspan = 1
                     for i in range(nplots):
                         self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
                 def plot_iq(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     yreal = y[channelIndexList,:].real
                     yimag = y[channelIndexList,:].imag
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity - IQ"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = min(numpy.nanmin(yreal),numpy.nanmin(yimag))
                         if ymax == None: ymax = max(numpy.nanmax(yreal),numpy.nanmax(yimag))
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         axes.pline(x, yreal[i,:],
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                         axes.addpline(x, yimag[i,:], idline=1, color="red", linestyle="solid", lw=2)
                 def plot_power(self, x, y, id, channelIndexList, thisDatetime, wintitle, show, xmin, xmax, ymin, ymax):
                     y = y[channelIndexList,:] * numpy.conjugate(y[channelIndexList,:])
                     yreal = y.real
                     title = wintitle + " Scope: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
                     xlabel = "Range (Km)"
                     ylabel = "Intensity"
                     if not self.isConfig:
                         nplots = len(channelIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle='',
                                    show=show)
                         if xmin == None: xmin = numpy.nanmin(x)
                         if xmax == None: xmax = numpy.nanmax(x)
                         if ymin == None: ymin = numpy.nanmin(yreal)
                         if ymax == None: ymax = numpy.nanmax(yreal)
                         self.isConfig = True
                     self.setWinTitle(title)
                     for i in range(len(self.axesList)):
                         title = "Channel %d" %(i)
                         axes = self.axesList[i]
                         ychannel = yreal[i,:]
                         axes.pline(x, ychannel,
                                     xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,
                                     xlabel=xlabel, ylabel=ylabel, title=title)
                 def run(self, dataOut, id, wintitle="", channelList=None,
                         xmin=None, xmax=None, ymin=None, ymax=None, save=False,
                         figpath='./', figfile=None, show=True, wr_period=1,
                         ftp=False, server=None, folder=None, username=None, password=None, type='power', **kwargs):
                     """
                     Input:
                         dataOut         :
                         id        :
                         wintitle        :
                         channelList     :
                         xmin            :    None,
                         xmax            :    None,
                         ymin            :    None,
                         ymax            :    None,
                     """
                     if dataOut.flagNoData:
                         return dataOut
                     if channelList == None:
                         channelIndexList = dataOut.channelIndexList
                     else:
                         channelIndexList = []
                         for channel in channelList:
                             if channel not in dataOut.channelList:
                                 raise ValueError("Channel %d is not in dataOut.channelList")
                             channelIndexList.append(dataOut.channelList.index(channel))
                     thisDatetime = datetime.datetime.utcfromtimestamp(dataOut.getTimeRange()[0])
                     if dataOut.flagDataAsBlock:
                         for i in range(dataOut.nProfiles):
                             wintitle1 = wintitle + " [Profile = %d] " %i
                             if type == "power":
                                 self.plot_power(dataOut.heightList,
                                                 dataOut.data[:,i,:],
                                                 id,
                                                 channelIndexList,
                                                 thisDatetime,
                                                 wintitle1,
                                                 show,
                                                 xmin,
                                                 xmax,
                                                 ymin,
                                                 ymax)
                             if type == "iq":
                                 self.plot_iq(dataOut.heightList,
                                              dataOut.data[:,i,:],
                                              id,
                                              channelIndexList,
                                              thisDatetime,
                                              wintitle1,
                                              show,
                                              xmin,
                                              xmax,
                                              ymin,
                                              ymax)
                             self.draw()
                             str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S")
                             figfile = self.getFilename(name = str_datetime) + "_" + str(i)
                             self.save(figpath=figpath,
                                       figfile=figfile,
                                       save=save,
                                       ftp=ftp,
                                       wr_period=wr_period,
                                       thisDatetime=thisDatetime)
                     else:
                         wintitle += " [Profile = %d] " %dataOut.profileIndex
                         if type == "power":
                             self.plot_power(dataOut.heightList,
                                             dataOut.data,
                                             id,
                                             channelIndexList,
                                             thisDatetime,
                                             wintitle,
                                             show,
                                             xmin,
                                             xmax,
                                             ymin,
                                             ymax)
                         if type == "iq":
                             self.plot_iq(dataOut.heightList,
                                          dataOut.data,
                                          id,
                                          channelIndexList,
                                          thisDatetime,
                                          wintitle,
                                          show,
                                          xmin,
                                          xmax,
                                          ymin,
                                          ymax)
                     self.draw()
                     str_datetime = thisDatetime.strftime("%Y%m%d_%H%M%S") + "_" + str(dataOut.profileIndex)
                     figfile = self.getFilename(name = str_datetime)
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime)
                     return dataOut

schainpy/model/proc/jroproc_base.py +100 -91

             '''
             Updated for multiprocessing
             Author : Sergio Cortez
             Jan 2018
             Abstract:
                 Base class for processing units and operations. A decorator provides multiprocessing features and interconnect the processes created.
                 The argument (kwargs) sent from the controller is parsed and filtered via the decorator for each processing unit or operation instantiated.
                 The decorator handle also the methods inside the processing unit to be called from the main script (not as operations) (OPERATION -> type ='self').
             Based on:
                 $Author: murco $
                 $Id: jroproc_base.py 1 2012-11-12 18:56:07Z murco $
             '''
-            from platform import python_version
             import inspect
             import zmq
             import time
             import pickle
             import os
             from multiprocessing import Process
+            from zmq.utils.monitor import recv_monitor_message
             from schainpy.utils import log
             class ProcessingUnit(object):
                 """
                 Update - Jan 2018 - MULTIPROCESSING
                 All the "call" methods present in the previous base were removed.
                 The majority of operations are independant processes, thus
                 the decorator is in charge of communicate the operation processes
                 with the proccessing unit via IPC.
                 The constructor does not receive any argument. The remaining methods
                 are related with the operations to execute.
                 """
-                METHODS = {}
-                dataIn = None
-                dataInList = []
-                id = None
-                inputId = None
-                dataOut = None
-                dictProcs = None
-                isConfig = False
                 def __init__(self):
                     self.dataIn = None
                     self.dataOut = None
                     self.isConfig = False
                     self.operations = []
+                    self.plots = []
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
-                def addOperation(self, conf, operation):
+                def addOperation(self, conf, operation):
                     """
                     This method is used in the controller, and update the dictionary containing the operations to execute. The dict
                     posses the id of the operation process (IPC purposes)
                         Agrega un objeto del tipo "Operation" (opObj) a la lista de objetos "self.objectList" y retorna el
                         identificador asociado a este objeto.
                         Input:
                             object    :    objeto de la clase "Operation"
                         Return:
                             objId    :    identificador del objeto, necesario para comunicar con master(procUnit)
                     """
-                    self.operations.append((operation, conf.type, conf.id, conf.getKwargs()))
+                    self.operations.append(
+                        (operation, conf.type, conf.id, conf.getKwargs()))
+                    if 'plot' in self.name.lower():
+                        self.plots.append(operation.CODE)
                 def getOperationObj(self, objId):
                     if objId not in list(self.operations.keys()):
                         return None
                     return self.operations[objId]
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataOut.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     raise NotImplementedError
                 def setup(self):
                     raise NotImplementedError
                 def run(self):
                     raise NotImplementedError
                 def close(self):
-                    #Close every thread, queue or any other object here is it is neccesary.
                     return
             class Operation(object):
                 """
                 Update - Jan 2018 - MULTIPROCESSING
                 Most of the methods remained the same. The decorator parse the arguments and executed the run() method for each process.
                 The constructor doe snot receive any argument, neither the baseclass.
                     Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                     y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                     acumulacion dentro de esta clase
                     Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
-                id = None
-                __buffer = None
-                dest = None
-                isConfig = False
-                readyFlag = None
                 def __init__(self):
-                    self.buffer = None
+                    self.id = None
-                    self.dest = None
                     self.isConfig = False
-                    self.readyFlag = 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):
-                    pass
+                    return
             def MPDecorator(BaseClass):
                 """
                 Multiprocessing class decorator
                 This function add multiprocessing features to a BaseClass. Also, it handle
                 the communication beetween processes (readers, procUnits and operations).
                 """
                 class MPClass(BaseClass, Process):
                     def __init__(self, *args, **kwargs):
                         super(MPClass, self).__init__()
                         Process.__init__(self)
                         self.operationKwargs = {}
                         self.args = args
                         self.kwargs = kwargs
                         self.sender = None
                         self.receiver = None
                         self.name = BaseClass.__name__
+                        self.start_time = time.time()
                         if len(self.args) is 3:
                             self.typeProc = "ProcUnit"
                             self.id = args[0]
                             self.inputId = args[1]
                             self.project_id = args[2]
-                        else:
+                        elif len(self.args) is 2:
                             self.id = args[0]
                             self.inputId = args[0]
                             self.project_id = args[1]
                             self.typeProc = "Operation"
-                    def getAllowedArgs(self):
-                        if hasattr(self, '__attrs__'):
-                            return self.__attrs__
-                        else:
-                            return inspect.getargspec(BaseClass.run).args
                     def subscribe(self):
                         '''
                         This function create a socket to receive objects from the
                         topic `inputId`.
                         '''
                         c = zmq.Context()
                         self.receiver = c.socket(zmq.SUB)
-                        self.receiver.connect('ipc:///tmp/schain/{}_pub'.format(self.project_id))
+                        self.receiver.connect(
+                            'ipc:///tmp/schain/{}_pub'.format(self.project_id))
                         self.receiver.setsockopt(zmq.SUBSCRIBE, self.inputId.encode())
                     def listen(self):
                         '''
                         This function waits for objects and deserialize using pickle
                         '''
-                        data =  pickle.loads(self.receiver.recv_multipart()[1])
+                        data = pickle.loads(self.receiver.recv_multipart()[1])
                         return data
                     def set_publisher(self):
                         '''
                         This function create a socket for publishing purposes.
                         '''
                         time.sleep(1)
                         c = zmq.Context()
                         self.sender = c.socket(zmq.PUB)
-                        self.sender.connect('ipc:///tmp/schain/{}_sub'.format(self.project_id))
+                        self.sender.connect(
+                            'ipc:///tmp/schain/{}_sub'.format(self.project_id))
                     def publish(self, data, id):
                         '''
                         This function publish an object, to a specific topic.
                         '''
                         self.sender.send_multipart([str(id).encode(), pickle.dumps(data)])
                     def runReader(self):
                         '''
                         Run fuction for read units
                         '''
                         while True:
-                            BaseClass.run(self, **self.kwargs)
-                            if self.dataOut.error[0] == -1:
+                            BaseClass.run(self, **self.kwargs)
-                                log.error(self.dataOut.error[1])
-                                self.publish('end', self.id)
-                                #self.sender.send_multipart([str(self.project_id).encode(), 'end'.encode()])
-                                break
-                            for op, optype, id, kwargs in self.operations:
+                            for op, optype, opId, kwargs in self.operations:
-                                if optype=='self':
+                                if optype == 'self':
                                     op(**kwargs)
-                                elif optype=='other':
+                                elif optype == 'other':
                                     self.dataOut = op.run(self.dataOut, **self.kwargs)
-                                elif optype=='external':
+                                elif optype == 'external':
                                     self.publish(self.dataOut, opId)
-                            if self.dataOut.flagNoData:
+                            if self.dataOut.flagNoData and self.dataOut.error is None:
                                 continue
                             self.publish(self.dataOut, self.id)
+                            if self.dataOut.error:
+                                if self.dataOut.error[0] == -1:
+                                    log.error(self.dataOut.error[1], self.name)
+                                if self.dataOut.error[0] == 1:
+                                    log.success(self.dataOut.error[1], self.name)
+                                # self.sender.send_multipart([str(self.project_id).encode(), 'end'.encode()])
+                                break
+                        time.sleep(1)
                     def runProc(self):
                         '''
                         Run function for proccessing units
                         '''
                         while True:
                             self.dataIn = self.listen()
-                            if self.dataIn == 'end':
+                            if self.dataIn.flagNoData and self.dataIn.error is None:
-                                self.publish('end', self.id)
-                                for op, optype, opId, kwargs in self.operations:
-                                    if optype == 'external':
-                                        self.publish('end', opId)
-                                break
-                            if self.dataIn.flagNoData:
                                 continue
                             BaseClass.run(self, **self.kwargs)
                             for op, optype, opId, kwargs in self.operations:
-                                if optype=='self':
+                                if optype == 'self':
                                     op(**kwargs)
-                                elif optype=='other':
+                                elif optype == 'other':
                                     self.dataOut = op.run(self.dataOut, **kwargs)
-                                elif optype=='external':
+                                elif optype == 'external':
                                     self.publish(self.dataOut, opId)
-                            if self.dataOut.flagNoData:
-                                continue
                             self.publish(self.dataOut, self.id)
+                            if self.dataIn.error:
+                                break
+                        time.sleep(1)
                     def runOp(self):
                         '''
-                        Run function for operations
+                        Run function for external operations (this operations just receive data
+                        ex: plots, writers, publishers)
                         '''
                         while True:
                             dataOut = self.listen()
-                            if dataOut == 'end':
-                                break
                             BaseClass.run(self, dataOut, **self.kwargs)
+                            if dataOut.error:
+                                break
+                        time.sleep(1)
                     def run(self):
                         if self.typeProc is "ProcUnit":
                             if self.inputId is not None:
                                 self.subscribe()
                             self.set_publisher()
                             if 'Reader' not in BaseClass.__name__:
                                 self.runProc()
                             else:
                                 self.runReader()
                         elif self.typeProc is "Operation":
                             self.subscribe()
                             self.runOp()
                         else:
                             raise ValueError("Unknown type")
-                        print("%s done" % BaseClass.__name__)
                         self.close()
+                    def event_monitor(self, monitor):
+                        events = {}
+                        for name in dir(zmq):
+                            if name.startswith('EVENT_'):
+                                value = getattr(zmq, name)
+                                events[value] = name
+                        while monitor.poll():
+                            evt = recv_monitor_message(monitor)
+                            if evt['event'] == 32:
+                                self.connections += 1
+                            if evt['event'] == 512:
+                                pass
+                            evt.update({'description': events[evt['event']]})
+                            if evt['event'] == zmq.EVENT_MONITOR_STOPPED:
+                                break
+                        monitor.close()
+                        print('event monitor thread done!')
                     def close(self):
+                        BaseClass.close(self)
                         if self.sender:
                             self.sender.close()
                         if self.receiver:
                             self.receiver.close()
-                return MPClass
  No newline at end of file
+                        log.success('Done...(Time:{:4.2f} secs)'.format(time.time()-self.start_time), self.name)
+                return MPClass

schainpy/model/utils/jroutils_publish.py +26 -586

This diff has been collapsed as it changes many lines, (612 lines changed) Show them Hide them
	@@ -1,869 +1,309
	1	'''	1	'''
	2	@author: Juan C. Espinoza	2	@author: Juan C. Espinoza
	3	'''	3	'''
	4		4
	5	import os	5	import os
	6	import glob	6	import glob
	7	import time	7	import time
	8	import json	8	import json
	9	import numpy	9	import numpy
	10	import paho.mqtt.client as mqtt
	11	import zmq	10	import zmq
	12	import datetime	11	import datetime
	13	import ftplib	12	import ftplib
	14	from zmq.utils.monitor import recv_monitor_message
	15	from functools import wraps	13	from functools import wraps
	16	from threading import Thread	14	from threading import Thread
	17	from multiprocessing import Process	15	from multiprocessing import Process
	18		16
	19	from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit	17	from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
	20	from schainpy.model.data.jrodata import JROData	18	from schainpy.model.data.jrodata import JROData
	21	from schainpy.utils import log	19	from schainpy.utils import log
	22		20
	23	MAXNUMX = 500	21	MAXNUMX = 500
	24	MAXNUMY = 500	22	MAXNUMY = 500
	25		23
	26	PLOT_CODES = {	24	PLOT_CODES = {
	27	'rti': 0, # Range time intensity (RTI).	25	'rti': 0, # Range time intensity (RTI).
	28	'spc': 1, # Spectra (and Cross-spectra) information.	26	'spc': 1, # Spectra (and Cross-spectra) information.
	29	'cspc': 2, # Cross-Correlation information.	27	'cspc': 2, # Cross-Correlation information.
	30	'coh': 3, # Coherence map.	28	'coh': 3, # Coherence map.
	31	'base': 4, # Base lines graphic.	29	'base': 4, # Base lines graphic.
	32	'row': 5, # Row Spectra.	30	'row': 5, # Row Spectra.
	33	'total': 6, # Total Power.	31	'total': 6, # Total Power.
	34	'drift': 7, # Drifts graphics.	32	'drift': 7, # Drifts graphics.
	35	'height': 8, # Height profile.	33	'height': 8, # Height profile.
	36	'phase': 9, # Signal Phase.	34	'phase': 9, # Signal Phase.
	37	'power': 16,	35	'power': 16,
	38	'noise': 17,	36	'noise': 17,
	39	'beacon': 18,	37	'beacon': 18,
	40	'wind': 22,	38	'wind': 22,
	41	'skymap': 23,	39	'skymap': 23,
	42	'Unknown': 24,	40	'Unknown': 24,
	43	'V-E': 25, # PIP Velocity.	41	'V-E': 25, # PIP Velocity.
	44	'Z-E': 26, # PIP Reflectivity.	42	'Z-E': 26, # PIP Reflectivity.
	45	'V-A': 27, # RHI Velocity.	43	'V-A': 27, # RHI Velocity.
	46	'Z-A': 28, # RHI Reflectivity.	44	'Z-A': 28, # RHI Reflectivity.
	47	}	45	}
	48		46
	49	def get_plot_code(s):	47	def get_plot_code(s):
	50	label = s.split('_')[0]	48	label = s.split('_')[0]
	51	codes = [key for key in PLOT_CODES if key in label]	49	codes = [key for key in PLOT_CODES if key in label]
	52	if codes:	50	if codes:
	53	return PLOT_CODES[codes[0]]	51	return PLOT_CODES[codes[0]]
	54	else:	52	else:
	55	return 24	53	return 24
	56		54
	57	def roundFloats(obj):
	58	if isinstance(obj, list):
	59	return list(map(roundFloats, obj))
	60	elif isinstance(obj, float):
	61	return round(obj, 2)
	62
	63	def decimate(z, MAXNUMY):	55	def decimate(z, MAXNUMY):
	64	dy = int(len(z[0])/MAXNUMY) + 1	56	dy = int(len(z[0])/MAXNUMY) + 1
	65		57
	66	return z[::, ::dy]	58	return z[::, ::dy]
	67		59
	68	class throttle(object):
	69	'''
	70	Decorator that prevents a function from being called more than once every
	71	time period.
	72	To create a function that cannot be called more than once a minute, but
	73	will sleep until it can be called:
	74	@throttle(minutes=1)
	75	def foo():
	76	pass
	77
	78	for i in range(10):
	79	foo()
	80	print "This function has run %s times." % i
	81	'''
	82
	83	def __init__(self, seconds=0, minutes=0, hours=0):
	84	self.throttle_period = datetime.timedelta(
	85	seconds=seconds, minutes=minutes, hours=hours
	86	)
	87
	88	self.time_of_last_call = datetime.datetime.min
	89
	90	def __call__(self, fn):
	91	@wraps(fn)
	92	def wrapper(args, *kwargs):
	93	coerce = kwargs.pop('coerce', None)
	94	if coerce:
	95	self.time_of_last_call = datetime.datetime.now()
	96	return fn(args, *kwargs)
	97	else:
	98	now = datetime.datetime.now()
	99	time_since_last_call = now - self.time_of_last_call
	100	time_left = self.throttle_period - time_since_last_call
	101
	102	if time_left > datetime.timedelta(seconds=0):
	103	return
	104
	105	self.time_of_last_call = datetime.datetime.now()
	106	return fn(args, *kwargs)
	107
	108	return wrapper
	109
	110	class Data(object):
	111	'''
	112	Object to hold data to be plotted
	113	'''
	114
	115	def __init__(self, plottypes, throttle_value, exp_code, buffering=True):
	116	self.plottypes = plottypes
	117	self.throttle = throttle_value
	118	self.exp_code = exp_code
	119	self.buffering = buffering
	120	self.ended = False
	121	self.localtime = False
	122	self.meta = {}
	123	self.__times = []
	124	self.__heights = []
	125
	126	def __str__(self):
	127	dum = ['{}{}'.format(key, self.shape(key)) for key in self.data]
	128	return 'Data[{}][{}]'.format(';'.join(dum), len(self.__times))
	129
	130	def __len__(self):
	131	return len(self.__times)
	132
	133	def __getitem__(self, key):
	134	if key not in self.data:
	135	raise KeyError(log.error('Missing key: {}'.format(key)))
	136
	137	if 'spc' in key or not self.buffering:
	138	ret = self.data[key]
	139	else:
	140	ret = numpy.array([self.data[key][x] for x in self.times])
	141	if ret.ndim > 1:
	142	ret = numpy.swapaxes(ret, 0, 1)
	143	return ret
	144
	145	def __contains__(self, key):
	146	return key in self.data
	147
	148	def setup(self):
	149	'''
	150	Configure object
	151	'''
	152
	153	self.type = ''
	154	self.ended = False
	155	self.data = {}
	156	self.__times = []
	157	self.__heights = []
	158	self.__all_heights = set()
	159	for plot in self.plottypes:
	160	if 'snr' in plot:
	161	plot = 'snr'
	162	self.data[plot] = {}
	163
	164	def shape(self, key):
	165	'''
	166	Get the shape of the one-element data for the given key
	167	'''
	168
	169	if len(self.data[key]):
	170	if 'spc' in key or not self.buffering:
	171	return self.data[key].shape
	172	return self.data[key][self.__times[0]].shape
	173	return (0,)
	174
	175	def update(self, dataOut, tm):
	176	'''
	177	Update data object with new dataOut
	178	'''
	179
	180	if tm in self.__times:
	181	return
	182
	183	self.type = dataOut.type
	184	self.parameters = getattr(dataOut, 'parameters', [])
	185	if hasattr(dataOut, 'pairsList'):
	186	self.pairs = dataOut.pairsList
	187	if hasattr(dataOut, 'meta'):
	188	self.meta = dataOut.meta
	189	self.channels = dataOut.channelList
	190	self.interval = dataOut.getTimeInterval()
	191	self.localtime = dataOut.useLocalTime
	192	if 'spc' in self.plottypes or 'cspc' in self.plottypes:
	193	self.xrange = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
	194	self.__heights.append(dataOut.heightList)
	195	self.__all_heights.update(dataOut.heightList)
	196	self.__times.append(tm)
	197
	198	for plot in self.plottypes:
	199	if plot == 'spc':
	200	z = dataOut.data_spc/dataOut.normFactor
	201	buffer = 10*numpy.log10(z)
	202	if plot == 'cspc':
	203	buffer = dataOut.data_cspc
	204	if plot == 'noise':
	205	buffer = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
	206	if plot == 'rti':
	207	buffer = dataOut.getPower()
	208	if plot == 'snr_db':
	209	buffer = dataOut.data_SNR
	210	if plot == 'snr':
	211	buffer = 10*numpy.log10(dataOut.data_SNR)
	212	if plot == 'dop':
	213	buffer = 10*numpy.log10(dataOut.data_DOP)
	214	if plot == 'mean':
	215	buffer = dataOut.data_MEAN
	216	if plot == 'std':
	217	buffer = dataOut.data_STD
	218	if plot == 'coh':
	219	buffer = dataOut.getCoherence()
	220	if plot == 'phase':
	221	buffer = dataOut.getCoherence(phase=True)
	222	if plot == 'output':
	223	buffer = dataOut.data_output
	224	if plot == 'param':
	225	buffer = dataOut.data_param
	226
	227	if 'spc' in plot:
	228	self.data[plot] = buffer
	229	else:
	230	if self.buffering:
	231	self.data[plot][tm] = buffer
	232	else:
	233	self.data[plot] = buffer
	234
	235	def normalize_heights(self):
	236	'''
	237	Ensure same-dimension of the data for different heighList
	238	'''
	239
	240	H = numpy.array(list(self.__all_heights))
	241	H.sort()
	242	for key in self.data:
	243	shape = self.shape(key)[:-1] + H.shape
	244	for tm, obj in list(self.data[key].items()):
	245	h = self.__heights[self.__times.index(tm)]
	246	if H.size == h.size:
	247	continue
	248	index = numpy.where(numpy.in1d(H, h))[0]
	249	dummy = numpy.zeros(shape) + numpy.nan
	250	if len(shape) == 2:
	251	dummy[:, index] = obj
	252	else:
	253	dummy[index] = obj
	254	self.data[key][tm] = dummy
	255
	256	self.__heights = [H for tm in self.__times]
	257
	258	def jsonify(self, decimate=False):
	259	'''
	260	Convert data to json
	261	'''
	262
	263	data = {}
	264	tm = self.times[-1]
	265	dy = int(self.heights.size/MAXNUMY) + 1
	266	for key in self.data:
	267	if key in ('spc', 'cspc') or not self.buffering:
	268	dx = int(self.data[key].shape[1]/MAXNUMX) + 1
	269	data[key] = roundFloats(self.data[key][::, ::dx, ::dy].tolist())
	270	else:
	271	data[key] = roundFloats(self.data[key][tm].tolist())
	272
	273	ret = {'data': data}
	274	ret['exp_code'] = self.exp_code
	275	ret['time'] = tm
	276	ret['interval'] = self.interval
	277	ret['localtime'] = self.localtime
	278	ret['yrange'] = roundFloats(self.heights[::dy].tolist())
	279	if 'spc' in self.data or 'cspc' in self.data:
	280	ret['xrange'] = roundFloats(self.xrange[2][::dx].tolist())
	281	else:
	282	ret['xrange'] = []
	283	if hasattr(self, 'pairs'):
	284	ret['pairs'] = self.pairs
	285	else:
	286	ret['pairs'] = []
	287
	288	for key, value in list(self.meta.items()):
	289	ret[key] = value
	290
	291	return json.dumps(ret)
	292
	293	@property
	294	def times(self):
	295	'''
	296	Return the list of times of the current data
	297	'''
	298
	299	ret = numpy.array(self.__times)
	300	ret.sort()
	301	return ret
	302
	303	@property
	304	def heights(self):
	305	'''
	306	Return the list of heights of the current data
	307	'''
	308
	309	return numpy.array(self.__heights[-1])
	310		60
	311	class PublishData(Operation):	61	class PublishData(Operation):
	312	'''	62	'''
	313	Operation to send data over zmq.	63	Operation to send data over zmq.
	314	'''	64	'''
	315		65
	316	__attrs__ = ['host', 'port', 'delay', '~~zeromq'~~, ~~'mqtt'~~, 'verbose']	66	__attrs__ = ['host', 'port', 'delay', 'verbose']
	317		67
	318	def __init__(self, **kwargs):	68	def __init__(self, **kwargs):
	319	"""Inicio."""	69	"""Inicio."""
	320	Operation.__init__(self, **kwargs)	70	Operation.__init__(self, **kwargs)
	321	self.isConfig = False	71	self.isConfig = False
	322	self.client = None
	323	self.zeromq = None
	324	self.mqtt = None
	325		72
	326	def on_disconnect(self, client, userdata, rc):	73	def setup(self, server='zmq.pipe', delay=0, verbose=True, **kwargs):
	327	if rc != 0:
	328	log.warning('Unexpected disconnection.')
	329	self.connect()
	330
	331	def connect(self):
	332	log.warning('trying to connect')
	333	try:
	334	self.client.connect(
	335	host=self.host,
	336	port=self.port,
	337	keepalive=60*10,
	338	bind_address='')
	339	self.client.loop_start()
	340	# self.client.publish(
	341	# self.topic + 'SETUP',
	342	# json.dumps(setup),
	343	# retain=True
	344	# )
	345	except:
	346	log.error('MQTT Conection error.')
	347	self.client = False
	348
	349	def setup(self, port=1883, username=None, password=None, clientId="user", zeromq=1, verbose=True, **kwargs):
	350	self.counter = 0	74	self.counter = 0
	351	self.topic = kwargs.get('topic', 'schain')
	352	self.delay = kwargs.get('delay', 0)	75	self.delay = kwargs.get('delay', 0)
	353	self.plottype = kwargs.get('plottype', 'spectra')
	354	self.host = kwargs.get('host', "10.10.10.82")
	355	self.port = kwargs.get('port', 3000)
	356	self.clientId = clientId
	357	self.cnt = 0	76	self.cnt = 0
	358	self.zeromq = zeromq
	359	self.mqtt = kwargs.get('plottype', 0)
	360	self.client = None
	361	self.verbose = verbose	77	self.verbose = verbose
	362	setup = []	78	setup = []
	363	if mqtt is 1:	79	context = zmq.Context()
	364	self.client = mqtt.Client(	80	self.zmq_socket = context.socket(zmq.PUSH)
	365	client_id=self.clientId + self.topic + 'SCHAIN',	81	server = kwargs.get('server', 'zmq.pipe')
	366	clean_session=True)	82
	367	self.client.on_disconnect = self.on_disconnect	83	if 'tcp://' in server:
	368	self.connect()	84	address = server
	369	for plot in self.plottype:	85	else:
	370	setup.append({	86	address = 'ipc:///tmp/%s' % server
	371	'plot': plot,	87
	372	'topic': self.topic + plot,	88	self.zmq_socket.connect(address)
	373	'title': getattr(self, plot + '_' + 'title', False),	89	time.sleep(1)
	374	'xlabel': getattr(self, plot + '_' + 'xlabel', False),
	375	'ylabel': getattr(self, plot + '_' + 'ylabel', False),
	376	'xrange': getattr(self, plot + '_' + 'xrange', False),
	377	'yrange': getattr(self, plot + '_' + 'yrange', False),
	378	'zrange': getattr(self, plot + '_' + 'zrange', False),
	379	})
	380	if zeromq is 1:
	381	context = zmq.Context()
	382	self.zmq_socket = context.socket(zmq.PUSH)
	383	server = kwargs.get('server', 'zmq.pipe')
	384
	385	if 'tcp://' in server:
	386	address = server
	387	else:
	388	address = 'ipc:///tmp/%s' % server
	389
	390	self.zmq_socket.connect(address)
	391	time.sleep(1)
	392		90
	393		91
	394	def publish_data(self):	92	def publish_data(self):
	395	self.dataOut.finished = False	93	self.dataOut.finished = False
	396	if self.mqtt is 1:	94
	397	yData = self.dataOut.heightList[:2].tolist()	95	if self.verbose:
	398	if self.plottype == 'spectra':	96	log.log(
	399	data = getattr(self.dataOut, 'data_spc')	97	'Sending {} - {}'.format(self.dataOut.type, self.dataOut.datatime),
	400	z = ~~data~~/self.~~dataOut~~.~~normFactor~~	98	self.name
	401	zdB = 10*numpy.log10(z)	99	)
	402	xlen, ylen = zdB[0].shape	100	self.zmq_socket.send_pyobj(self.dataOut)
	403	dx = int(xlen/MAXNUMX) + 1
	404	dy = int(ylen/MAXNUMY) + 1
	405	Z = [0 for i in self.dataOut.channelList]
	406	for i in self.dataOut.channelList:
	407	Z[i] = zdB[i][::dx, ::dy].tolist()
	408	payload = {
	409	'timestamp': self.dataOut.utctime,
	410	'data': roundFloats(Z),
	411	'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
	412	'interval': self.dataOut.getTimeInterval(),
	413	'type': self.plottype,
	414	'yData': yData
	415	}
	416
	417	elif self.plottype in ('rti', 'power'):
	418	data = getattr(self.dataOut, 'data_spc')
	419	z = data/self.dataOut.normFactor
	420	avg = numpy.average(z, axis=1)
	421	avgdB = 10*numpy.log10(avg)
	422	xlen, ylen = z[0].shape
	423	dy = numpy.floor(ylen/self.__MAXNUMY) + 1
	424	AVG = [0 for i in self.dataOut.channelList]
	425	for i in self.dataOut.channelList:
	426	AVG[i] = avgdB[i][::dy].tolist()
	427	payload = {
	428	'timestamp': self.dataOut.utctime,
	429	'data': roundFloats(AVG),
	430	'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
	431	'interval': self.dataOut.getTimeInterval(),
	432	'type': self.plottype,
	433	'yData': yData
	434	}
	435	elif self.plottype == 'noise':
	436	noise = self.dataOut.getNoise()/self.dataOut.normFactor
	437	noisedB = 10*numpy.log10(noise)
	438	payload = {
	439	'timestamp': self.dataOut.utctime,
	440	'data': roundFloats(noisedB.reshape(-1, 1).tolist()),
	441	'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
	442	'interval': self.dataOut.getTimeInterval(),
	443	'type': self.plottype,
	444	'yData': yData
	445	}
	446	elif self.plottype == 'snr':
	447	data = getattr(self.dataOut, 'data_SNR')
	448	avgdB = 10*numpy.log10(data)
	449
	450	ylen = data[0].size
	451	dy = numpy.floor(ylen/self.__MAXNUMY) + 1
	452	AVG = [0 for i in self.dataOut.channelList]
	453	for i in self.dataOut.channelList:
	454	AVG[i] = avgdB[i][::dy].tolist()
	455	payload = {
	456	'timestamp': self.dataOut.utctime,
	457	'data': roundFloats(AVG),
	458	'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
	459	'type': self.plottype,
	460	'yData': yData
	461	}
	462	else:
	463	print("Tipo de grafico invalido")
	464	payload = {
	465	'data': 'None',
	466	'timestamp': 'None',
	467	'type': None
	468	}
	469
	470	self.client.publish(self.topic + self.plottype, json.dumps(payload), qos=0)
	471
	472	if self.zeromq is 1:
	473	if self.verbose:
	474	log.log(
	475	'Sending {} - {}'.format(self.dataOut.type, self.dataOut.datatime),
	476	self.name
	477	)
	478	self.zmq_socket.send_pyobj(self.dataOut)
	479		101
	480	def run(self, dataOut, **kwargs):	102	def run(self, dataOut, **kwargs):
	481	self.dataOut = dataOut	103	self.dataOut = dataOut
	482	if not self.isConfig:	104	if not self.isConfig:
	483	self.setup(**kwargs)	105	self.setup(**kwargs)
	484	self.isConfig = True	106	self.isConfig = True
	485		107
	486	self.publish_data()	108	self.publish_data()
	487	time.sleep(self.delay)	109	time.sleep(self.delay)
	488		110
	489	def close(self):	111	def close(self):
	490	if self.zeromq is 1:	112
	491	self.dataOut.finished = True	113	self.dataOut.finished = True
	492	self.zmq_socket.send_pyobj(self.dataOut)	114	self.zmq_socket.send_pyobj(self.dataOut)
	493	time.sleep(0.1)	115	time.sleep(0.1)
	494	self.zmq_socket.close()	116	self.zmq_socket.close()
	495	if self.client:	117
	496	self.client.loop_stop()
	497	self.client.disconnect()
	498
	499		118
	500	class ReceiverData(ProcessingUnit):	119	class ReceiverData(ProcessingUnit):
	501		120
	502	__attrs__ = ['server']	121	__attrs__ = ['server']
	503		122
	504	def __init__(self, **kwargs):	123	def __init__(self, **kwargs):
	505		124
	506	ProcessingUnit.__init__(self, **kwargs)	125	ProcessingUnit.__init__(self, **kwargs)
	507		126
	508	self.isConfig = False	127	self.isConfig = False
	509	server = kwargs.get('server', 'zmq.pipe')	128	server = kwargs.get('server', 'zmq.pipe')
	510	if 'tcp://' in server:	129	if 'tcp://' in server:
	511	address = server	130	address = server
	512	else:	131	else:
	513	address = 'ipc:///tmp/%s' % server	132	address = 'ipc:///tmp/%s' % server
	514		133
	515	self.address = address	134	self.address = address
	516	self.dataOut = JROData()	135	self.dataOut = JROData()
	517		136
	518	def setup(self):	137	def setup(self):
	519		138
	520	self.context = zmq.Context()	139	self.context = zmq.Context()
	521	self.receiver = self.context.socket(zmq.PULL)	140	self.receiver = self.context.socket(zmq.PULL)
	522	self.receiver.bind(self.address)	141	self.receiver.bind(self.address)
	523	time.sleep(0.5)	142	time.sleep(0.5)
	524	log.success('ReceiverData from {}'.format(self.address))	143	log.success('ReceiverData from {}'.format(self.address))
	525		144
	526		145
	527	def run(self):	146	def run(self):
	528		147
	529	if not self.isConfig:	148	if not self.isConfig:
	530	self.setup()	149	self.setup()
	531	self.isConfig = True	150	self.isConfig = True
	532		151
	533	self.dataOut = self.receiver.recv_pyobj()	152	self.dataOut = self.receiver.recv_pyobj()
	534	log.log('{} - {}'.format(self.dataOut.type,	153	log.log('{} - {}'.format(self.dataOut.type,
	535	self.dataOut.datatime.ctime(),),	154	self.dataOut.datatime.ctime(),),
	536	'Receiving')	155	'Receiving')
	537		156
	538		157
	539	class PlotterReceiver(ProcessingUnit, Process):
	540
	541	throttle_value = 5
	542	__attrs__ = ['server', 'plottypes', 'realtime', 'localtime', 'throttle',
	543	'exp_code', 'web_server', 'buffering']
	544
	545	def __init__(self, **kwargs):
	546
	547	ProcessingUnit.__init__(self, **kwargs)
	548	Process.__init__(self)
	549	self.mp = False
	550	self.isConfig = False
	551	self.isWebConfig = False
	552	self.connections = 0
	553	server = kwargs.get('server', 'zmq.pipe')
	554	web_server = kwargs.get('web_server', None)
	555	if 'tcp://' in server:
	556	address = server
	557	else:
	558	address = 'ipc:///tmp/%s' % server
	559	self.address = address
	560	self.web_address = web_server
	561	self.plottypes = [s.strip() for s in kwargs.get('plottypes', 'rti').split(',')]
	562	self.realtime = kwargs.get('realtime', False)
	563	self.localtime = kwargs.get('localtime', True)
	564	self.buffering = kwargs.get('buffering', True)
	565	self.throttle_value = kwargs.get('throttle', 5)
	566	self.exp_code = kwargs.get('exp_code', None)
	567	self.sendData = self.initThrottle(self.throttle_value)
	568	self.dates = []
	569	self.setup()
	570
	571	def setup(self):
	572
	573	self.data = Data(self.plottypes, self.throttle_value, self.exp_code, self.buffering)
	574	self.isConfig = True
	575
	576	def event_monitor(self, monitor):
	577
	578	events = {}
	579
	580	for name in dir(zmq):
	581	if name.startswith('EVENT_'):
	582	value = getattr(zmq, name)
	583	events[value] = name
	584
	585	while monitor.poll():
	586	evt = recv_monitor_message(monitor)
	587	if evt['event'] == 32:
	588	self.connections += 1
	589	if evt['event'] == 512:
	590	pass
	591
	592	evt.update({'description': events[evt['event']]})
	593
	594	if evt['event'] == zmq.EVENT_MONITOR_STOPPED:
	595	break
	596	monitor.close()
	597	print('event monitor thread done!')
	598
	599	def initThrottle(self, throttle_value):
	600
	601	@throttle(seconds=throttle_value)
	602	def sendDataThrottled(fn_sender, data):
	603	fn_sender(data)
	604
	605	return sendDataThrottled
	606
	607	def send(self, data):
	608	log.log('Sending {}'.format(data), self.name)
	609	self.sender.send_pyobj(data)
	610
	611	def run(self):
	612
	613	log.log(
	614	'Starting from {}'.format(self.address),
	615	self.name
	616	)
	617
	618	self.context = zmq.Context()
	619	self.receiver = self.context.socket(zmq.PULL)
	620	self.receiver.bind(self.address)
	621	monitor = self.receiver.get_monitor_socket()
	622	self.sender = self.context.socket(zmq.PUB)
	623	if self.web_address:
	624	log.success(
	625	'Sending to web: {}'.format(self.web_address),
	626	self.name
	627	)
	628	self.sender_web = self.context.socket(zmq.REQ)
	629	self.sender_web.connect(self.web_address)
	630	self.poll = zmq.Poller()
	631	self.poll.register(self.sender_web, zmq.POLLIN)
	632	time.sleep(1)
	633
	634	if 'server' in self.kwargs:
	635	self.sender.bind("ipc:///tmp/{}.plots".format(self.kwargs['server']))
	636	else:
	637	self.sender.bind("ipc:///tmp/zmq.plots")
	638
	639	time.sleep(2)
	640
	641	t = Thread(target=self.event_monitor, args=(monitor,))
	642	t.start()
	643
	644	while True:
	645	dataOut = self.receiver.recv_pyobj()
	646	if not dataOut.flagNoData:
	647	if dataOut.type == 'Parameters':
	648	tm = dataOut.utctimeInit
	649	else:
	650	tm = dataOut.utctime
	651	if dataOut.useLocalTime:
	652	if not self.localtime:
	653	tm += time.timezone
	654	dt = datetime.datetime.fromtimestamp(tm).date()
	655	else:
	656	if self.localtime:
	657	tm -= time.timezone
	658	dt = datetime.datetime.utcfromtimestamp(tm).date()
	659	coerce = False
	660	if dt not in self.dates:
	661	if self.data:
	662	self.data.ended = True
	663	self.send(self.data)
	664	coerce = True
	665	self.data.setup()
	666	self.dates.append(dt)
	667
	668	self.data.update(dataOut, tm)
	669
	670	if dataOut.finished is True:
	671	self.connections -= 1
	672	if self.connections == 0 and dt in self.dates:
	673	self.data.ended = True
	674	self.send(self.data)
	675	# self.data.setup()
	676	time.sleep(1)
	677	break
	678	else:
	679	if self.realtime:
	680	self.send(self.data)
	681	if self.web_address:
	682	retries = 5
	683	while True:
	684	self.sender_web.send(self.data.jsonify())
	685	socks = dict(self.poll.poll(5000))
	686	if socks.get(self.sender_web) == zmq.POLLIN:
	687	reply = self.sender_web.recv_string()
	688	if reply == 'ok':
	689	log.log("Response from server ok", self.name)
	690	break
	691	else:
	692	log.warning("Malformed reply from server: {}".format(reply), self.name)
	693
	694	else:
	695	log.warning("No response from server, retrying...", self.name)
	696	self.sender_web.setsockopt(zmq.LINGER, 0)
	697	self.sender_web.close()
	698	self.poll.unregister(self.sender_web)
	699	retries -= 1
	700	if retries == 0:
	701	log.error("Server seems to be offline, abandoning", self.name)
	702	self.sender_web = self.context.socket(zmq.REQ)
	703	self.sender_web.connect(self.web_address)
	704	self.poll.register(self.sender_web, zmq.POLLIN)
	705	time.sleep(1)
	706	break
	707	self.sender_web = self.context.socket(zmq.REQ)
	708	self.sender_web.connect(self.web_address)
	709	self.poll.register(self.sender_web, zmq.POLLIN)
	710	time.sleep(1)
	711	else:
	712	self.sendData(self.send, self.data, coerce=coerce)
	713	coerce = False
	714
	715	return
	716
	717
	718	class SendToFTP(Operation, Process):	158	class SendToFTP(Operation, Process):
	719		159
	720	'''	160	'''
	721	Operation to send data over FTP.	161	Operation to send data over FTP.
	722	'''	162	'''
	723		163
	724	__attrs__ = ['server', 'username', 'password', 'patterns', 'timeout']	164	__attrs__ = ['server', 'username', 'password', 'patterns', 'timeout']
	725		165
	726	def __init__(self, **kwargs):	166	def __init__(self, **kwargs):
	727	'''	167	'''
	728	patterns = [(local1, remote1, ext, delay, exp_code, sub_exp_code), ...]	168	patterns = [(local1, remote1, ext, delay, exp_code, sub_exp_code), ...]
	729	'''	169	'''
	730	Operation.__init__(self, **kwargs)	170	Operation.__init__(self, **kwargs)
	731	Process.__init__(self)	171	Process.__init__(self)
	732	self.server = kwargs.get('server')	172	self.server = kwargs.get('server')
	733	self.username = kwargs.get('username')	173	self.username = kwargs.get('username')
	734	self.password = kwargs.get('password')	174	self.password = kwargs.get('password')
	735	self.patterns = kwargs.get('patterns')	175	self.patterns = kwargs.get('patterns')
	736	self.timeout = kwargs.get('timeout', 30)	176	self.timeout = kwargs.get('timeout', 30)
	737	self.times = [time.time() for p in self.patterns]	177	self.times = [time.time() for p in self.patterns]
	738	self.latest = ['' for p in self.patterns]	178	self.latest = ['' for p in self.patterns]
	739	self.mp = False	179	self.mp = False
	740	self.ftp = None	180	self.ftp = None
	741		181
	742	def setup(self):	182	def setup(self):
	743		183
	744	log.log('Connecting to ftp://{}'.format(self.server), self.name)	184	log.log('Connecting to ftp://{}'.format(self.server), self.name)
	745	try:	185	try:
	746	self.ftp = ftplib.FTP(self.server, timeout=self.timeout)	186	self.ftp = ftplib.FTP(self.server, timeout=self.timeout)
	747	except ftplib.all_errors:	187	except ftplib.all_errors:
	748	log.error('Server connection fail: {}'.format(self.server), self.name)	188	log.error('Server connection fail: {}'.format(self.server), self.name)
	749	if self.ftp is not None:	189	if self.ftp is not None:
	750	self.ftp.close()	190	self.ftp.close()
	751	self.ftp = None	191	self.ftp = None
	752	self.isConfig = False	192	self.isConfig = False
	753	return	193	return
	754		194
	755	try:	195	try:
	756	self.ftp.login(self.username, self.password)	196	self.ftp.login(self.username, self.password)
	757	except ftplib.all_errors:	197	except ftplib.all_errors:
	758	log.error('The given username y/o password are incorrect', self.name)	198	log.error('The given username y/o password are incorrect', self.name)
	759	if self.ftp is not None:	199	if self.ftp is not None:
	760	self.ftp.close()	200	self.ftp.close()
	761	self.ftp = None	201	self.ftp = None
	762	self.isConfig = False	202	self.isConfig = False
	763	return	203	return
	764		204
	765	log.success('Connection success', self.name)	205	log.success('Connection success', self.name)
	766	self.isConfig = True	206	self.isConfig = True
	767	return	207	return
	768		208
	769	def check(self):	209	def check(self):
	770		210
	771	try:	211	try:
	772	self.ftp.voidcmd("NOOP")	212	self.ftp.voidcmd("NOOP")
	773	except:	213	except:
	774	log.warning('Connection lost... trying to reconnect', self.name)	214	log.warning('Connection lost... trying to reconnect', self.name)
	775	if self.ftp is not None:	215	if self.ftp is not None:
	776	self.ftp.close()	216	self.ftp.close()
	777	self.ftp = None	217	self.ftp = None
	778	self.setup()	218	self.setup()
	779		219
	780	def find_files(self, path, ext):	220	def find_files(self, path, ext):
	781		221
	782	files = glob.glob1(path, '*{}'.format(ext))	222	files = glob.glob1(path, '*{}'.format(ext))
	783	files.sort()	223	files.sort()
	784	if files:	224	if files:
	785	return files[-1]	225	return files[-1]
	786	return None	226	return None
	787		227
	788	def getftpname(self, filename, exp_code, sub_exp_code):	228	def getftpname(self, filename, exp_code, sub_exp_code):
	789		229
	790	thisDatetime = datetime.datetime.strptime(filename.split('_')[1], '%Y%m%d')	230	thisDatetime = datetime.datetime.strptime(filename.split('_')[1], '%Y%m%d')
	791	YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year	231	YEAR_STR = '%4.4d'%thisDatetime.timetuple().tm_year
	792	DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday	232	DOY_STR = '%3.3d'%thisDatetime.timetuple().tm_yday
	793	exp_code = '%3.3d'%exp_code	233	exp_code = '%3.3d'%exp_code
	794	sub_exp_code = '%2.2d'%sub_exp_code	234	sub_exp_code = '%2.2d'%sub_exp_code
	795	plot_code = '%2.2d'% get_plot_code(filename)	235	plot_code = '%2.2d'% get_plot_code(filename)
	796	name = YEAR_STR + DOY_STR + '00' + exp_code + sub_exp_code + plot_code + '00.png'	236	name = YEAR_STR + DOY_STR + '00' + exp_code + sub_exp_code + plot_code + '00.png'
	797	return name	237	return name
	798		238
	799	def upload(self, src, dst):	239	def upload(self, src, dst):
	800		240
	801	log.log('Uploading {} '.format(src), self.name, nl=False)	241	log.log('Uploading {} '.format(src), self.name, nl=False)
	802		242
	803	fp = open(src, 'rb')	243	fp = open(src, 'rb')
	804	command = 'STOR {}'.format(dst)	244	command = 'STOR {}'.format(dst)
	805		245
	806	try:	246	try:
	807	self.ftp.storbinary(command, fp, blocksize=1024)	247	self.ftp.storbinary(command, fp, blocksize=1024)
	808	except Exception as e:	248	except Exception as e:
	809	log.error('{}'.format(e), self.name)	249	log.error('{}'.format(e), self.name)
	810	if self.ftp is not None:	250	if self.ftp is not None:
	811	self.ftp.close()	251	self.ftp.close()
	812	self.ftp = None	252	self.ftp = None
	813	return 0	253	return 0
	814		254
	815	try:	255	try:
	816	self.ftp.sendcmd('SITE CHMOD 755 {}'.format(dst))	256	self.ftp.sendcmd('SITE CHMOD 755 {}'.format(dst))
	817	except Exception as e:	257	except Exception as e:
	818	log.error('{}'.format(e), self.name)	258	log.error('{}'.format(e), self.name)
	819	if self.ftp is not None:	259	if self.ftp is not None:
	820	self.ftp.close()	260	self.ftp.close()
	821	self.ftp = None	261	self.ftp = None
	822	return 0	262	return 0
	823		263
	824	fp.close()	264	fp.close()
	825	log.success('OK', tag='')	265	log.success('OK', tag='')
	826	return 1	266	return 1
	827		267
	828	def send_files(self):	268	def send_files(self):
	829		269
	830	for x, pattern in enumerate(self.patterns):	270	for x, pattern in enumerate(self.patterns):
	831	local, remote, ext, delay, exp_code, sub_exp_code = pattern	271	local, remote, ext, delay, exp_code, sub_exp_code = pattern
	832	if time.time()-self.times[x] >= delay:	272	if time.time()-self.times[x] >= delay:
	833	srcname = self.find_files(local, ext)	273	srcname = self.find_files(local, ext)
	834	src = os.path.join(local, srcname)	274	src = os.path.join(local, srcname)
	835	if os.path.getmtime(src) < time.time() - 30*60:	275	if os.path.getmtime(src) < time.time() - 30*60:
	836	continue	276	continue
	837		277
	838	if srcname is None or srcname == self.latest[x]:	278	if srcname is None or srcname == self.latest[x]:
	839	continue	279	continue
	840		280
	841	if 'png' in ext:	281	if 'png' in ext:
	842	dstname = self.getftpname(srcname, exp_code, sub_exp_code)	282	dstname = self.getftpname(srcname, exp_code, sub_exp_code)
	843	else:	283	else:
	844	dstname = srcname	284	dstname = srcname
	845		285
	846	dst = os.path.join(remote, dstname)	286	dst = os.path.join(remote, dstname)
	847		287
	848	if self.upload(src, dst):	288	if self.upload(src, dst):
	849	self.times[x] = time.time()	289	self.times[x] = time.time()
	850	self.latest[x] = srcname	290	self.latest[x] = srcname
	851	else:	291	else:
	852	self.isConfig = False	292	self.isConfig = False
	853	break	293	break
	854		294
	855	def run(self):	295	def run(self):
	856		296
	857	while True:	297	while True:
	858	if not self.isConfig:	298	if not self.isConfig:
	859	self.setup()	299	self.setup()
	860	if self.ftp is not None:	300	if self.ftp is not None:
	861	self.check()	301	self.check()
	862	self.send_files()	302	self.send_files()
	863	time.sleep(10)	303	time.sleep(10)
	864		304
	865	def close():	305	def close():
	866		306
	867	if self.ftp is not None:	307	if self.ftp is not None:
	868	self.ftp.close()	308	self.ftp.close()
	869	self.terminate() No newline at end of file	309	self.terminate()

schainpy/model/graphics/jroplotter.py removed 0 -240

NO CONTENT: file was removed

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