schain Commit - r1062:8048843f4edf · Jicamarca Repository

Fix publish and plots operations issue #929

Juan C. Espinoza -

r1062:8048843f4edf

parent child

Context file:

r1062:8048843f4edf

Collapse all files

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

schainpy/model/data/jrodata.py 0 0

NO CONTENT: modified file

schainpy/model/graphics/jroplot_data.py +470 -652

This diff has been collapsed as it changes many lines, (1122 lines changed) Show them Hide them
	@@ -1,964 +1,782
	1		1
	2	import os	2	import os
	3	import zmq
	4	import time	3	import time
	5	import ~~numpy~~	4	import glob
	6	import datetime	5	import datetime
	7	import numpy as np	6	from multiprocessing import Process
			7
			8	import zmq
			9	import numpy
	8	import matplotlib	10	import matplotlib
	9	import glob
	10	matplotlib.use('TkAgg')
	11	import matplotlib.pyplot as plt	11	import matplotlib.pyplot as plt
	12	from mpl_toolkits.axes_grid1 import make_axes_locatable	12	from mpl_toolkits.axes_grid1 import make_axes_locatable
	13	from matplotlib.ticker import FuncFormatter, LinearLocator	13	from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
	14	from multiprocessing import Process
	15		14
	16	from schainpy.model.proc.jroproc_base import Operation	15	from schainpy.model.proc.jroproc_base import Operation
	17		16	from schainpy.utils import log
	18	plt.ion()
	19		17
	20	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))	18	func = lambda x, pos: ('%s') %(datetime.datetime.fromtimestamp(x).strftime('%H:%M'))
	21	fromtimestamp = lambda x, mintime : (datetime.datetime.utcfromtimestamp(mintime).replace(hour=(x + 5), minute=0) - d1970).total_seconds()
	22
	23		19
	24	d1970 = datetime.datetime(1970,1,1)	20	d1970 = datetime.datetime(1970, 1, 1)
	25		21
			22
	26	class PlotData(Operation, Process):	23	class PlotData(Operation, Process):
			24	'''
			25	Base class for Schain plotting operations
			26	'''
	27		27
	28	CODE = 'Figure'	28	CODE = 'Figure'
	29	colormap = 'jro'	29	colormap = 'jro'
			30	bgcolor = 'white'
	30	CONFLATE = False	31	CONFLATE = False
	31	__MAXNUMX = 80	32	__MAXNUMX = 80
	32	__missing = 1E30	33	__missing = 1E30
	33		34
	34	def __init__(self, **kwargs):	35	def __init__(self, **kwargs):
	35		36
	36	Operation.__init__(self, plot=True, **kwargs)	37	Operation.__init__(self, plot=True, **kwargs)
	37	Process.__init__(self)	38	Process.__init__(self)
	38	self.kwargs['code'] = self.CODE	39	self.kwargs['code'] = self.CODE
	39	self.mp = False	40	self.mp = False
	40	self.data~~Out~~ = None	41	self.data = None
	41	self.isConfig = False	42	self.isConfig = False
	42	self.figure = ~~None~~	43	self.figures = []
	43	self.axes = []	44	self.axes = []
			45	self.cb_axes = []
	44	self.localtime = kwargs.pop('localtime', True)	46	self.localtime = kwargs.pop('localtime', True)
	45	self.show = kwargs.get('show', True)	47	self.show = kwargs.get('show', True)
	46	self.save = kwargs.get('save', False)	48	self.save = kwargs.get('save', False)
	47	self.colormap = kwargs.get('colormap', self.colormap)	49	self.colormap = kwargs.get('colormap', self.colormap)
	48	self.colormap_coh = kwargs.get('colormap_coh', 'jet')	50	self.colormap_coh = kwargs.get('colormap_coh', 'jet')
	49	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')	51	self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
	50	self.~~showprofile~~ = kwargs.get('~~showprofile~~', ~~Tru~~e)	52	self.colormaps = kwargs.get('colormaps', None)
	51	self.~~title~~ = kwargs.get('~~wintitle~~', '')	53	self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
			54	self.showprofile = kwargs.get('showprofile', False)
			55	self.title = kwargs.get('wintitle', self.CODE.upper())
			56	self.cb_label = kwargs.get('cb_label', None)
			57	self.cb_labels = kwargs.get('cb_labels', None)
	52	self.xaxis = kwargs.get('xaxis', 'frequency')	58	self.xaxis = kwargs.get('xaxis', 'frequency')
	53	self.zmin = kwargs.get('zmin', None)	59	self.zmin = kwargs.get('zmin', None)
	54	self.zmax = kwargs.get('zmax', None)	60	self.zmax = kwargs.get('zmax', None)
			61	self.zlimits = kwargs.get('zlimits', None)
	55	self.xmin = kwargs.get('xmin', None)	62	self.xmin = kwargs.get('xmin', None)
			63	if self.xmin is not None:
			64	self.xmin += 5
	56	self.xmax = kwargs.get('xmax', None)	65	self.xmax = kwargs.get('xmax', None)
	57	self.xrange = kwargs.get('xrange', 24)	66	self.xrange = kwargs.get('xrange', 24)
	58	self.ymin = kwargs.get('ymin', None)	67	self.ymin = kwargs.get('ymin', None)
	59	self.ymax = kwargs.get('ymax', None)	68	self.ymax = kwargs.get('ymax', None)
	60	self.~~__MAXNUMY~~ = kwargs.get('~~decimation~~', ~~5000~~)	69	self.xlabel = kwargs.get('xlabel', None)
	61	self.throttle_value = 5	70	self.__MAXNUMY = kwargs.get('decimation', 100)
	62	self.times = []	71	self.showSNR = kwargs.get('showSNR', False)
	63	#self.interactive = self.kwargs['parent']	72	self.oneFigure = kwargs.get('oneFigure', True)
			73	self.width = kwargs.get('width', None)
			74	self.height = kwargs.get('height', None)
			75	self.colorbar = kwargs.get('colorbar', True)
			76	self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
			77	self.titles = ['' for __ in range(16)]
			78
			79	def __setup(self):
			80	'''
			81	Common setup for all figures, here figures and axes are created
			82	'''
			83
			84	self.setup()
			85
			86	if self.width is None:
			87	self.width = 8
			88
			89	self.figures = []
			90	self.axes = []
			91	self.cb_axes = []
			92	self.pf_axes = []
			93	self.cmaps = []
	64		94
			95	size = '15%' if self.ncols==1 else '30%'
			96	pad = '4%' if self.ncols==1 else '8%'
			97
			98	if self.oneFigure:
			99	if self.height is None:
			100	self.height = 1.4*self.nrows + 1
			101	fig = plt.figure(figsize=(self.width, self.height),
			102	edgecolor='k',
			103	facecolor='w')
			104	self.figures.append(fig)
			105	for n in range(self.nplots):
			106	ax = fig.add_subplot(self.nrows, self.ncols, n+1)
			107	ax.tick_params(labelsize=8)
			108	ax.firsttime = True
			109	self.axes.append(ax)
			110	if self.showprofile:
			111	cax = self.__add_axes(ax, size=size, pad=pad)
			112	cax.tick_params(labelsize=8)
			113	self.pf_axes.append(cax)
			114	else:
			115	if self.height is None:
			116	self.height = 3
			117	for n in range(self.nplots):
			118	fig = plt.figure(figsize=(self.width, self.height),
			119	edgecolor='k',
			120	facecolor='w')
			121	ax = fig.add_subplot(1, 1, 1)
			122	ax.tick_params(labelsize=8)
			123	ax.firsttime = True
			124	self.figures.append(fig)
			125	self.axes.append(ax)
			126	if self.showprofile:
			127	cax = self.__add_axes(ax, size=size, pad=pad)
			128	cax.tick_params(labelsize=8)
			129	self.pf_axes.append(cax)
			130
			131	for n in range(self.nrows):
			132	if self.colormaps is not None:
			133	cmap = plt.get_cmap(self.colormaps[n])
			134	else:
			135	cmap = plt.get_cmap(self.colormap)
			136	cmap.set_bad(self.bgcolor, 1.)
			137	self.cmaps.append(cmap)
			138
			139	def __add_axes(self, ax, size='30%', pad='8%'):
	65	'''	140	'''
	66	this new parameter is created to plot data from varius channels at different figures	141	Add new axes to the given figure
	67	1. crear una lista de figuras donde se puedan plotear las figuras,
	68	2. dar las opciones de configuracion a cada figura, estas opciones son iguales para ambas figuras
	69	3. probar?
	70	'''	142	'''
	71	self.ind_plt_ch = kwargs.get('ind_plt_ch', False)	143	divider = make_axes_locatable(ax)
	72	self.figurelist = None	144	nax = divider.new_horizontal(size=size, pad=pad)
			145	ax.figure.add_axes(nax)
			146	return nax
	73		147
	74		148
	75	def fill_gaps(self, x_buffer, y_buffer, z_buffer):	149	def setup(self):
			150	'''
			151	This method should be implemented in the child class, the following
			152	attributes should be set:
	76		153
			154	self.nrows: number of rows
			155	self.ncols: number of cols
			156	self.nplots: number of plots (channels or pairs)
			157	self.ylabel: label for Y axes
			158	self.titles: list of axes title
			159
			160	'''
			161	raise(NotImplementedError, 'Implement this method in child class')
			162
			163	def fill_gaps(self, x_buffer, y_buffer, z_buffer):
			164	'''
			165	Create a masked array for missing data
			166	'''
	77	if x_buffer.shape[0] < 2:	167	if x_buffer.shape[0] < 2:
	78	return x_buffer, y_buffer, z_buffer	168	return x_buffer, y_buffer, z_buffer
	79		169
	80	deltas = x_buffer[1:] - x_buffer[0:-1]	170	deltas = x_buffer[1:] - x_buffer[0:-1]
	81	x_median = np.median(deltas)	171	x_median = numpy.median(deltas)
	82		172
	83	index = np.where(deltas > 5*x_median)	173	index = numpy.where(deltas > 5*x_median)
	84		174
	85	if len(index[0]) != 0:	175	if len(index[0]) != 0:
	86	z_buffer[::, index[0], ::] = self.__missing	176	z_buffer[::, index[0], ::] = self.__missing
	87	z_buffer = np.ma.masked_inside(z_buffer,	177	z_buffer = numpy.ma.masked_inside(z_buffer,
	88	0.99*self.__missing,	178	0.99*self.__missing,
	89	1.01*self.__missing)	179	1.01*self.__missing)
	90		180
	91	return x_buffer, y_buffer, z_buffer	181	return x_buffer, y_buffer, z_buffer
	92		182
	93	def decimate(self):	183	def decimate(self):
	94		184
	95	# dx = int(len(self.x)/self.__MAXNUMX) + 1	185	# dx = int(len(self.x)/self.__MAXNUMX) + 1
	96	dy = int(len(self.y)/self.__MAXNUMY) + 1	186	dy = int(len(self.y)/self.__MAXNUMY) + 1
	97		187
	98	# x = self.x[::dx]	188	# x = self.x[::dx]
	99	x = self.x	189	x = self.x
	100	y = self.y[::dy]	190	y = self.y[::dy]
	101	z = self.z[::, ::, ::dy]	191	z = self.z[::, ::, ::dy]
	102		192
	103	return x, y, z	193	return x, y, z
	104		194
			195	def format(self):
	105	'''	196	'''
	106	JM:	197	Set min and max values, labels, ticks and titles
	107	elimana las otras imagenes generadas debido a que lso workers no llegan en orden y le pueden
	108	poner otro tiempo a la figura q no necesariamente es el ultimo.
	109	Solo se realiza cuando termina la imagen.
	110	Problemas:
	111
	112	File "/home/ci-81/workspace/schainv2.3/schainpy/model/graphics/jroplot_data.py", line 145, in __plot
	113	for n, eachfigure in enumerate(self.figurelist):
	114	TypeError: 'NoneType' object is not iterable
	115
	116	'''	198	'''
	117	def deleteanotherfiles(self):
	118	figurenames=[]
	119	if self.figurelist != None:
	120	for n, eachfigure in enumerate(self.figurelist):
	121	#add specific name for each channel in channelList
	122	ghostfigname = os.path.join(self.save, '{}_{}_{}'.format(self.titles[n].replace(' ',''),self.CODE,
	123	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))
	124	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,
	125	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	126		199
	127	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	200	if self.xmin is None:
	128	if ghostfigure != figname:	201	xmin = self.min_time
	129	os.remove(ghostfigure)	202	else:
	130	print 'Removing GhostFigures:' , figname	203	if self.xaxis is 'time':
			204	dt = datetime.datetime.fromtimestamp(self.min_time)
			205	xmin = (datetime.datetime.combine(dt.date(),
			206	datetime.time(int(self.xmin), 0, 0))-d1970).total_seconds()
	131	else :	207	else:
	132	'''Erasing ghost images for just on******************'''	208	xmin = self.xmin
	133	ghostfigname = os.path.join(self.save, '{}_{}'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d')))	209
	134	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	210	if self.xmax is None:
	135	for ghostfigure in glob.glob(ghostfigname+'*'): #ghostfigure will adopt all posible names of figures	211	xmax = xmin+self.xrange6060
	136	if ghostfigure != figname:	212	else:
	137	os.remove(ghostfigure)	213	if self.xaxis is 'time':
	138	print 'Removing GhostFigures:' , figname	214	dt = datetime.datetime.fromtimestamp(self.min_time)
			215	xmax = (datetime.datetime.combine(dt.date(),
			216	datetime.time(int(self.xmax), 0, 0))-d1970).total_seconds()
			217	else:
			218	xmax = self.xmax
			219
			220	ymin = self.ymin if self.ymin else numpy.nanmin(self.y)
			221	ymax = self.ymax if self.ymax else numpy.nanmax(self.y)
			222
			223	ystep = 200 if ymax>= 800 else 100 if ymax>=400 else 50 if ymax>=200 else 20
			224
			225	for n, ax in enumerate(self.axes):
			226	if ax.firsttime:
			227	ax.set_facecolor(self.bgcolor)
			228	ax.yaxis.set_major_locator(MultipleLocator(ystep))
			229	if self.xaxis is 'time':
			230	ax.xaxis.set_major_formatter(FuncFormatter(func))
			231	ax.xaxis.set_major_locator(LinearLocator(9))
			232	if self.xlabel is not None:
			233	ax.set_xlabel(self.xlabel)
			234	ax.set_ylabel(self.ylabel)
			235	ax.firsttime = False
			236	if self.showprofile:
			237	self.pf_axes[n].set_ylim(ymin, ymax)
			238	self.pf_axes[n].set_xlim(self.zmin, self.zmax)
			239	self.pf_axes[n].set_xlabel('dB')
			240	self.pf_axes[n].grid(b=True, axis='x')
			241	[tick.set_visible(False) for tick in self.pf_axes[n].get_yticklabels()]
			242	if self.colorbar:
			243	cb = plt.colorbar(ax.plt, ax=ax, pad=0.02)
			244	cb.ax.tick_params(labelsize=8)
			245	if self.cb_label:
			246	cb.set_label(self.cb_label, size=8)
			247	elif self.cb_labels:
			248	cb.set_label(self.cb_labels[n], size=8)
			249
			250	ax.set_title('{} - {} UTC'.format(
			251	self.titles[n],
			252	datetime.datetime.fromtimestamp(self.max_time).strftime('%H:%M:%S')),
			253	size=8)
			254	ax.set_xlim(xmin, xmax)
			255	ax.set_ylim(ymin, ymax)
			256
	139		257
	140	def __plot(self):	258	def __plot(self):
			259	'''
			260	'''
			261	log.success('Plotting', self.name)
	141		262
	142	print 'plotting...{}'.format(self.CODE)
	143	if self.ind_plt_ch is False : #standard
	144	if self.show:
	145	self.figure.show()
	146	self.plot()	263	self.plot()
	147	plt.tight_layout()	264	self.format()
	148	self.figure.canvas.manager.set_window_title('{} {} - {}'.format(self.title, self.CODE.upper(),	265
	149	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	266	for n, fig in enumerate(self.figures):
	150	else :	267	if self.nrows == 0 or self.nplots == 0:
	151	print 'len(self.figurelist): ',len(self.figurelist)	268	log.warning('No data', self.name)
	152	for n, eachfigure in enumerate(self.figurelist):	269	continue
	153	if self.show:	270	if self.show:
	154	~~each~~fig~~ure~~.show()	271	fig.show()
	155		272
	156	self.plot()	273	fig.tight_layout()
	157	eachfigure.tight_layout() # ajuste de cada subplot	274	fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
	158	eachfigure.canvas.manager.set_window_title('{} {} - {}'.format(self.title[n], self.CODE.upper(),
	159	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))	275	datetime.datetime.fromtimestamp(self.max_time).strftime('%Y/%m/%d')))
			276	# fig.canvas.draw()
	160		277
	161	# if self.save:	278	if self.save and self.data.ended:
	162	# if self.ind_plt_ch is False : #standard	279	channels = range(self.nrows)
	163	# figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,	280	if self.oneFigure:
	164	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	281	label = ''
	165	# print 'Saving figure: {}'.format(figname)
	166	# self.figure.savefig(figname)
	167	# else :
	168	# for n, eachfigure in enumerate(self.figurelist):
	169	# #add specific name for each channel in channelList
	170	# figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n],self.CODE,
	171	# datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	172	#
	173	# print 'Saving figure: {}'.format(figname)
	174	# eachfigure.savefig(figname)
	175
	176	if self.ind_plt_ch is False :
	177	self.figure.canvas.draw()
	178	else :
	179	for eachfigure in self.figurelist:
	180	eachfigure.canvas.draw()
	181
	182	if self.save:
	183	if self.ind_plt_ch is False : #standard
	184	figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE,
	185	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))
	186	print 'Saving figure: {}'.format(figname)
	187	self.figure.savefig(figname)
	188	else :	282	else:
	189	for n, eachfigure in enumerate(self.figurelist):	283	label = '_{}'.format(channels[n])
	190	#add specific name for each channel in channelList	284	figname = os.path.join(
	191	figname = os.path.join(self.save, '{}_{}_{}.png'.format(self.titles[n].replace(' ',''),self.CODE,	285	self.save,
	192	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')))	286	'{}{}_{}.png'.format(
	193		287	self.CODE,
			288	label,
			289	datetime.datetime.fromtimestamp(self.saveTime).strftime('%y%m%d_%H%M%S')
			290	)
			291	)
	194	print 'Saving figure: {}'.format(figname)	292	print 'Saving figure: {}'.format(figname)
	195	~~each~~fig~~ure~~.savefig(figname)	293	fig.savefig(figname)
	196
	197		294
	198	def plot(self):	295	def plot(self):
	199		296	'''
	200	print 'plotting...{}'.format(self.CODE.upper())	297	'''
	201	return	298	raise(NotImplementedError, 'Implement this method in child class')
	202		299
	203	def run(self):	300	def run(self):
	204		301
	205	~~print~~ ~~'[Starting] {}'~~.~~format~~(self.name)	302	log.success('Starting', self.name)
	206		303
	207	context = zmq.Context()	304	context = zmq.Context()
	208	receiver = context.socket(zmq.SUB)	305	receiver = context.socket(zmq.SUB)
	209	receiver.setsockopt(zmq.SUBSCRIBE, '')	306	receiver.setsockopt(zmq.SUBSCRIBE, '')
	210	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)	307	receiver.setsockopt(zmq.CONFLATE, self.CONFLATE)
	211		308
	212	if 'server' in self.kwargs['parent']:	309	if 'server' in self.kwargs['parent']:
	213	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))	310	receiver.connect('ipc:///tmp/{}.plots'.format(self.kwargs['parent']['server']))
	214	else:	311	else:
	215	receiver.connect("ipc:///tmp/zmq.plots")	312	receiver.connect("ipc:///tmp/zmq.plots")
	216		313
	217	seconds_passed = 0
	218
	219	while True:	314	while True:
	220	try:	315	try:
	221	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)~~#flags=zmq.NOBLOCK~~	316	self.data = receiver.recv_pyobj(flags=zmq.NOBLOCK)
	222	self.started = self.data['STARTED']
	223	self.dataOut = self.data['dataOut']
	224		317
	225	if (len(self.times) < len(self.data['times']) and not self.started and self.data['ENDED']):	318	self.min_time = self.data.times[0]
	226	continue	319	self.max_time = self.data.times[-1]
	227
	228	self.times = self.data['times']
	229	self.times.sort()
	230	self.throttle_value = self.data['throttle']
	231	self.min_time = self.times[0]
	232	self.max_time = self.times[-1]
	233		320
	234	if self.isConfig is False:	321	if self.isConfig is False:
	235	~~print~~ ~~'setting up'~~	322	self.__setup()
	236	self.setup()
	237	self.isConfig = True	323	self.isConfig = True
	238	self.__plot()
	239		324
	240	if self.data['ENDED'] is True:
	241	print '******GRAPHIC ENDED******'
	242	self.ended = True
	243	self.isConfig = False
	244	self.__plot()	325	self.__plot()
	245	self.deleteanotherfiles() #CLPDG
	246	elif seconds_passed >= self.data['throttle']:
	247	print 'passed', seconds_passed
	248	self.__plot()
	249	seconds_passed = 0
	250		326
	251	except zmq.Again as e:	327	except zmq.Again as e:
	252	~~print~~ 'Waiting for data...'	328	log.log('Waiting for data...')
	253	~~plt~~.~~pause~~(2)	329	if self.data:
	254	seconds_passed += 2	330	plt.pause(self.data.throttle)
			331	else:
			332	time.sleep(2)
	255		333
	256	def close(self):	334	def close(self):
	257	if self.data~~Out~~:	335	if self.data:
	258	self.__plot()	336	self.__plot()
	259		337
	260		338
	261	class PlotSpectraData(PlotData):	339	class PlotSpectraData(PlotData):
			340	'''
			341	Plot for Spectra data
			342	'''
	262		343
	263	CODE = 'spc'	344	CODE = 'spc'
	264	colormap = 'jro'	345	colormap = 'jro'
	265	CONFLATE = False
	266		346
	267	def setup(self):	347	def setup(self):
	268		348	self.nplots = len(self.data.channels)
	269	ncolspan = 1	349	self.ncols = int(numpy.sqrt(self.nplots)+ 0.9)
	270	colspan = 1	350	self.nrows = int((1.0*self.nplots/self.ncols) + 0.9)
	271	self.ncols = int(numpy.sqrt(self.dataOut.nChannels)+0.9)	351	self.width = 3.4*self.ncols
	272	self.nrows = int(self.dataOut.nChannels*1./self.ncols + 0.9)	352	self.height = 3*self.nrows
	273	self.width = 3.6*self.ncols	353	self.cb_label = 'dB'
	274	self.height = 3.2*self.nrows
	275	if self.showprofile:	354	if self.showprofile:
	276	ncolspan = 3	355	self.width += 0.8*self.ncols
	277	colspan = 2
	278	self.width += 1.2*self.ncols
	279		356
	280	self.ylabel = 'Range [Km]'	357	self.ylabel = 'Range [Km]'
	281	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]
	282
	283	if self.figure is None:
	284	self.figure = plt.figure(figsize=(self.width, self.height),
	285	edgecolor='k',
	286	facecolor='w')
	287	else:
	288	self.figure.clf()
	289
	290	n = 0
	291	for y in range(self.nrows):
	292	for x in range(self.ncols):
	293	if n >= self.dataOut.nChannels:
	294	break
	295	ax = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan), 1, colspan)
	296	if self.showprofile:
	297	ax.ax_profile = plt.subplot2grid((self.nrows, self.ncolsncolspan), (y, xncolspan+colspan), 1, 1)
	298
	299	ax.firsttime = True
	300	self.axes.append(ax)
	301	n += 1
	302		358
	303	def plot(self):	359	def plot(self):
	304
	305	if self.xaxis == "frequency":	360	if self.xaxis == "frequency":
	306	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	361	x = self.data.xrange[0]
	307	xlabel = "Frequency (kHz)"	362	self.xlabel = "Frequency (kHz)"
	308	elif self.xaxis == "time":	363	elif self.xaxis == "time":
	309	x = self.data~~Out~~.~~getAcfRange~~(1)	364	x = self.data.xrange[1]
	310	xlabel = "Time (ms)"	365	self.xlabel = "Time (ms)"
	311	else:	366	else:
	312	x = self.data~~Out~~.~~getVelRange~~(1)	367	x = self.data.xrange[2]
	313	xlabel = "Velocity (m/s)"	368	self.xlabel = "Velocity (m/s)"
			369
			370	if self.CODE == 'spc_mean':
			371	x = self.data.xrange[2]
			372	self.xlabel = "Velocity (m/s)"
	314		373
	315	y = self.dataOut.getHeiRange()	374	self.titles = []
	316	z = self.data[self.CODE]	375
			376	y = self.data.heights
			377	self.y = y
			378	z = self.data['spc']
	317		379
	318	for n, ax in enumerate(self.axes):	380	for n, ax in enumerate(self.axes):
			381	noise = self.data['noise'][n][-1]
			382	if self.CODE == 'spc_mean':
			383	mean = self.data['mean'][n][-1]
	319	if ax.firsttime:	384	if ax.firsttime:
	320	self.xmax = self.xmax if self.xmax else np.nanmax(x)	385	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	321	self.xmin = self.xmin if self.xmin else -self.xmax	386	self.xmin = self.xmin if self.xmin else -self.xmax
	322	self.ymin = self.ymin if self.ymin else np.nanmin(y)	387	self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
	323	self.ymax = self.ymax if self.ymax else np.nanmax(y)	388	self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
	324	self.zmin = self.zmin if self.zmin else np.nanmin(z)	389	ax.plt = ax.pcolormesh(x, y, z[n].T,
	325	self.zmax = self.zmax if self.zmax else np.nanmax(z)
	326	ax.plot = ax.pcolormesh(x, y, z[n].T,
	327	vmin=self.zmin,	390	vmin=self.zmin,
	328	vmax=self.zmax,	391	vmax=self.zmax,
	329	cmap=plt.get_cmap(self.colormap)	392	cmap=plt.get_cmap(self.colormap)
	330	)	393	)
	331	divider = make_axes_locatable(ax)
	332	cax = divider.new_horizontal(size='3%', pad=0.05)
	333	self.figure.add_axes(cax)
	334	plt.colorbar(ax.plot, cax)
	335
	336	ax.set_xlim(self.xmin, self.xmax)
	337	ax.set_ylim(self.ymin, self.ymax)
	338
	339	ax.set_ylabel(self.ylabel)
	340	ax.set_xlabel(xlabel)
	341
	342	ax.firsttime = False
	343		394
	344	if self.showprofile:	395	if self.showprofile:
	345	ax.plot_profile= ax.~~ax_profile~~.plot(self.data['rti'][~~self~~.~~max_time~~][n], y)[0]	396	ax.plt_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], y)[0]
	346	ax.ax_profile.set_xlim(self.zmin, self.zmax)	397	ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
	347	ax.ax_profile.set_ylim(self.ymin, self.ymax)	398	color="k", linestyle="dashed", lw=1)[0]
	348	ax.ax_profile.set_xlabel('dB')	399	if self.CODE == 'spc_mean':
	349	ax.ax_profile.grid(b=True, axis='x')	400	ax.plt_mean = ax.plot(mean, y, color='k')[0]
	350	ax.plot_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,
	351	color="k", linestyle="dashed", lw=2)[0]
	352	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	353	else:	401	else:
	354	ax.plot.set_array(z[n].T.ravel())	402	ax.plt.set_array(z[n].T.ravel())
	355	if self.showprofile:	403	if self.showprofile:
	356	ax.plot_profile.set_data(self.data['rti'][~~self~~.~~max_time~~][n], y)	404	ax.plt_profile.set_data(self.data['rti'][n][-1], y)
	357	ax.plot_noise.set_data(numpy.repeat(~~self~~.~~data~~['noise'][~~self~~.~~max_time~~][n], len(y)), y)	405	ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
			406	if self.CODE == 'spc_mean':
			407	ax.plt_mean.set_data(mean, y)
	358		408
	359	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),	409	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	360	size=8)
	361	self.saveTime = self.max_time	410	self.saveTime = self.max_time
	362		411
	363		412
	364	class PlotCrossSpectraData(PlotData):	413	class PlotCrossSpectraData(PlotData):
	365		414
	366	CODE = 'cspc'	415	CODE = 'cspc'
	367	zmin_coh = None	416	zmin_coh = None
	368	zmax_coh = None	417	zmax_coh = None
	369	zmin_phase = None	418	zmin_phase = None
	370	zmax_phase = None	419	zmax_phase = None
	371	CONFLATE = False
	372		420
	373	def setup(self):	421	def setup(self):
	374		422
	375	ncols~~pan~~ = 1	423	self.ncols = 4
	376	colspan = 1	424	self.nrows = len(self.data.pairs)
	377	self.n~~col~~s = 2	425	self.nplots = self.nrows*4
	378	self.~~nrows~~ = self.~~dataOut~~.~~nPair~~s	426	self.width = 3.4*self.ncols
	379	self.~~width~~ = 3.6*self.n~~col~~s	427	self.height = 3*self.nrows
	380	self.height = 3.2*self.nrows
	381
	382	self.ylabel = 'Range [Km]'	428	self.ylabel = 'Range [Km]'
	383	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	429	self.showprofile = False
	384
	385	if self.figure is None:
	386	self.figure = plt.figure(figsize=(self.width, self.height),
	387	edgecolor='k',
	388	facecolor='w')
	389	else:
	390	self.figure.clf()
	391
	392	for y in range(self.nrows):
	393	for x in range(self.ncols):
	394	ax = plt.subplot2grid((self.nrows, self.ncols), (y, x), 1, 1)
	395	ax.firsttime = True
	396	self.axes.append(ax)
	397		430
	398	def plot(self):	431	def plot(self):
	399		432
	400	if self.xaxis == "frequency":	433	if self.xaxis == "frequency":
	401	x = self.data~~Out~~.~~getFreqRange~~(1)/~~1000.~~	434	x = self.data.xrange[0]
	402	xlabel = "Frequency (kHz)"	435	self.xlabel = "Frequency (kHz)"
	403	elif self.xaxis == "time":	436	elif self.xaxis == "time":
	404	x = self.data~~Out~~.~~getAcfRange~~(1)	437	x = self.data.xrange[1]
	405	xlabel = "Time (ms)"	438	self.xlabel = "Time (ms)"
	406	else:	439	else:
	407	x = self.data~~Out~~.~~getVelRange~~(1)	440	x = self.data.xrange[2]
	408	xlabel = "Velocity (m/s)"	441	self.xlabel = "Velocity (m/s)"
			442
			443	self.titles = []
	409		444
	410	y = self.data~~Out~~.~~getHeiRange~~()	445	y = self.data.heights
	411	z_coh = self.data['cspc_coh']	446	self.y = y
	412	~~z_phase~~ = self.data['cspc~~_phase~~']	447	spc = self.data['spc']
			448	cspc = self.data['cspc']
	413		449
	414	for n in range(self.nrows):	450	for n in range(self.nrows):
	415	ax = self.~~axes~~[2*n]	451	noise = self.data['noise'][n][-1]
	416	~~ax1~~ = self.~~axe~~s[2*n+1]	452	pair = self.data.pairs[n]
			453	ax = self.axes[4*n]
			454	ax3 = self.axes[4*n+3]
	417	if ax.firsttime:	455	if ax.firsttime:
	418	self.xmax = self.xmax if self.xmax else np.nanmax(x)	456	self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
	419	self.xmin = self.xmin if self.xmin else -self.xmax	457	self.xmin = self.xmin if self.xmin else -self.xmax
	420	self.ymin = self.ymin if self.ymin else np.nanmin(y)	458	self.zmin = self.zmin if self.zmin else numpy.nanmin(spc)
	421	self.ymax = self.ymax if self.ymax else np.nanmax(y)	459	self.zmax = self.zmax if self.zmax else numpy.nanmax(spc)
	422	self.zmin_coh = self.zmin_coh if self.zmin_coh else 0.0	460	ax.plt = ax.pcolormesh(x, y, spc[pair[0]].T,
	423	self.zmax_coh = self.zmax_coh if self.zmax_coh else 1.0	461	vmin=self.zmin,
	424	self.zmin_phase = self.zmin_phase if self.zmin_phase else -180	462	vmax=self.zmax,
	425	self.zmax_phase = self.zmax_phase if self.zmax_phase else 180	463	cmap=plt.get_cmap(self.colormap)
	426
	427	ax.plot = ax.pcolormesh(x, y, z_coh[n].T,
	428	vmin=self.zmin_coh,
	429	vmax=self.zmax_coh,
	430	cmap=plt.get_cmap(self.colormap_coh)
	431	)
	432	divider = make_axes_locatable(ax)
	433	cax = divider.new_horizontal(size='3%', pad=0.05)
	434	self.figure.add_axes(cax)
	435	plt.colorbar(ax.plot, cax)
	436
	437	ax.set_xlim(self.xmin, self.xmax)
	438	ax.set_ylim(self.ymin, self.ymax)
	439
	440	ax.set_ylabel(self.ylabel)
	441	ax.set_xlabel(xlabel)
	442	ax.firsttime = False
	443
	444	ax1.plot = ax1.pcolormesh(x, y, z_phase[n].T,
	445	vmin=self.zmin_phase,
	446	vmax=self.zmax_phase,
	447	cmap=plt.get_cmap(self.colormap_phase)
	448	)	464	)
	449	divider = make_axes_locatable(ax1)
	450	cax = divider.new_horizontal(size='3%', pad=0.05)
	451	self.figure.add_axes(cax)
	452	plt.colorbar(ax1.plot, cax)
	453
	454	ax1.set_xlim(self.xmin, self.xmax)
	455	ax1.set_ylim(self.ymin, self.ymax)
	456
	457	ax1.set_ylabel(self.ylabel)
	458	ax1.set_xlabel(xlabel)
	459	ax1.firsttime = False
	460	else:	465	else:
	461	ax.plot.set_array(~~z_coh~~[n].T.ravel())	466	ax.plt.set_array(spc[pair[0]].T.ravel())
	462	ax1.plot.set_array(z_phase[n].T.ravel())	467	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	463
	464	ax.set_title('Coherence Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	465	ax1.set_title('Phase Ch{} * Ch{}'.format(self.dataOut.pairsList[n][0], self.dataOut.pairsList[n][1]), size=8)
	466	self.saveTime = self.max_time
	467
	468
	469	class PlotSpectraMeanData(PlotSpectraData):
	470
	471	CODE = 'spc_mean'
	472	colormap = 'jet'
	473
	474	def plot(self):
	475
	476	if self.xaxis == "frequency":
	477	x = self.dataOut.getFreqRange(1)/1000.
	478	xlabel = "Frequency (kHz)"
	479	elif self.xaxis == "time":
	480	x = self.dataOut.getAcfRange(1)
	481	xlabel = "Time (ms)"
	482	else:
	483	x = self.dataOut.getVelRange(1)
	484	xlabel = "Velocity (m/s)"
	485
	486	y = self.dataOut.getHeiRange()
	487	z = self.data['spc']
	488	mean = self.data['mean'][self.max_time]
	489
	490	for n, ax in enumerate(self.axes):
	491		468
			469	ax = self.axes[4*n+1]
	492	if ax.firsttime:	470	if ax.firsttime:
	493	self.xmax = self.xmax if self.xmax else np.nanmax(x)	471	ax.plt = ax.pcolormesh(x, y, spc[pair[1]].T,
	494	self.xmin = self.xmin if self.xmin else -self.xmax
	495	self.ymin = self.ymin if self.ymin else np.nanmin(y)
	496	self.ymax = self.ymax if self.ymax else np.nanmax(y)
	497	self.zmin = self.zmin if self.zmin else np.nanmin(z)
	498	self.zmax = self.zmax if self.zmax else np.nanmax(z)
	499	ax.plt = ax.pcolormesh(x, y, z[n].T,
	500	vmin=self.zmin,	472	vmin=self.zmin,
	501	vmax=self.zmax,	473	vmax=self.zmax,
	502	cmap=plt.get_cmap(self.colormap)	474	cmap=plt.get_cmap(self.colormap)
	503	)	475	)
	504	ax.plt_dop = ax.plot(mean[n], y,	476	else:
	505	color='k')[0]	477	ax.plt.set_array(spc[pair[1]].T.ravel())
	506		478	self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
	507	divider = make_axes_locatable(ax)
	508	cax = divider.new_horizontal(size='3%', pad=0.05)
	509	self.figure.add_axes(cax)
	510	plt.colorbar(ax.plt, cax)
	511
	512	ax.set_xlim(self.xmin, self.xmax)
	513	ax.set_ylim(self.ymin, self.ymax)
	514		479
	515	ax.set_ylabel(self.ylabel)	480	out = cspc[n]/numpy.sqrt(spc[pair[0]]*spc[pair[1]])
	516	ax.set_xlabel(xlabel)	481	coh = numpy.abs(out)
			482	phase = numpy.arctan2(out.imag, out.real)*180/numpy.pi
	517		483
	518	ax.firsttime = False	484	ax = self.axes[4*n+2]
			485	if ax.firsttime:
			486	ax.plt = ax.pcolormesh(x, y, coh.T,
			487	vmin=0,
			488	vmax=1,
			489	cmap=plt.get_cmap(self.colormap_coh)
			490	)
			491	else:
			492	ax.plt.set_array(coh.T.ravel())
			493	self.titles.append('Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
	519		494
	520	if self.showprofile:	495	ax = self.axes[4*n+3]
	521	ax.plt_profile= ax.ax_profile.plot(self.data['rti'][self.max_time][n], y)[0]	496	if ax.firsttime:
	522	ax.ax_profile.set_xlim(self.zmin, self.zmax)	497	ax.plt = ax.pcolormesh(x, y, phase.T,
	523	ax.ax_profile.set_ylim(self.ymin, self.ymax)	498	vmin=-180,
	524	ax.ax_profile.set_xlabel('dB')	499	vmax=180,
	525	ax.ax_profile.grid(b=True, axis='x')	500	cmap=plt.get_cmap(self.colormap_phase)
	526	ax.plt_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y,	501	)
	527	color="k", linestyle="dashed", lw=2)[0]
	528	[tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()]
	529	else:	502	else:
	530	ax.plt.set_array(z[n].T.ravel())	503	ax.plt.set_array(phase.T.ravel())
	531	ax.plt_dop.set_data(mean[n], y)	504	self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
	532	if self.showprofile:
	533	ax.plt_profile.set_data(self.data['rti'][self.max_time][n], y)
	534	ax.plt_noise.set_data(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y)
	535		505
	536	ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]),
	537	size=8)
	538	self.saveTime = self.max_time	506	self.saveTime = self.max_time
	539		507
	540		508
			509	class PlotSpectraMeanData(PlotSpectraData):
			510	'''
			511	Plot for Spectra and Mean
			512	'''
			513	CODE = 'spc_mean'
			514	colormap = 'jro'
			515
			516
	541	class PlotRTIData(PlotData):	517	class PlotRTIData(PlotData):
			518	'''
			519	Plot for RTI data
			520	'''
	542		521
	543	CODE = 'rti'	522	CODE = 'rti'
	544	colormap = 'jro'	523	colormap = 'jro'
	545		524
	546	def setup(self):	525	def setup(self):
			526	self.xaxis = 'time'
	547	self.ncols = 1	527	self.ncols = 1
	548	self.nrows = self.data~~Out~~.nChannels	528	self.nrows = len(self.data.channels)
	549	self.width = 10	529	self.nplots = len(self.data.channels)
	550	#TODO : arreglar la altura de la figura, esta hardcodeada.
	551	#Se arreglo, testear!
	552	if self.ind_plt_ch:
	553	self.height = 3.2#*self.nrows if self.nrows<6 else 12
	554	else:
	555	self.height = 2.2*self.nrows if self.nrows<6 else 12
	556
	557	'''
	558	if self.nrows==1:
	559	self.height += 1
	560	'''
	561	self.ylabel = 'Range [Km]'	530	self.ylabel = 'Range [Km]'
	562	self.titles = ['Channel {}'.format(x) for x in self.dataOut.channelList]	531	self.cb_label = 'dB'
	563		532	self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
	564	'''
	565	Logica:
	566	1) Si la variable ind_plt_ch es True, va a crear mas de 1 figura
	567	2) guardamos "Figures" en una lista y "axes" en otra, quizas se deberia guardar el
	568	axis dentro de "Figures" como un diccionario.
	569	'''
	570	if self.ind_plt_ch is False: #standard mode
	571
	572	if self.figure is None: #solo para la priemra vez
	573	self.figure = plt.figure(figsize=(self.width, self.height),
	574	edgecolor='k',
	575	facecolor='w')
	576	else:
	577	self.figure.clf()
	578	self.axes = []
	579
	580
	581	for n in range(self.nrows):
	582	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	583	#ax = self.figure(n+1)
	584	ax.firsttime = True
	585	self.axes.append(ax)
	586
	587	else : #append one figure foreach channel in channelList
	588	if self.figurelist == None:
	589	self.figurelist = []
	590	for n in range(self.nrows):
	591	self.figure = plt.figure(figsize=(self.width, self.height),
	592	edgecolor='k',
	593	facecolor='w')
	594	#add always one subplot
	595	self.figurelist.append(self.figure)
	596
	597	else : # cada dia nuevo limpia el axes, pero mantiene el figure
	598	for eachfigure in self.figurelist:
	599	eachfigure.clf() # eliminaria todas las figuras de la lista?
	600	self.axes = []
	601
	602	for eachfigure in self.figurelist:
	603	ax = eachfigure.add_subplot(1,1,1) #solo 1 axis por figura
	604	#ax = self.figure(n+1)
	605	ax.firsttime = True
	606	#Cada figura tiene un distinto puntero
	607	self.axes.append(ax)
	608	#plt.close(eachfigure)
	609
	610		533
	611	def plot(self):	534	def plot(self):
			535	self.x = self.data.times
			536	self.y = self.data.heights
			537	self.z = self.data[self.CODE]
			538	self.z = numpy.ma.masked_invalid(self.z)
	612		539
	613	if self.ind_plt_ch is False: #standard mode
	614	self.x = np.array(self.times)
	615	self.y = self.dataOut.getHeiRange()
	616	self.z = []
	617
	618	for ch in range(self.nrows):
	619	self.z.append([self.data[self.CODE][t][ch] for t in self.times])
	620
	621	self.z = np.array(self.z)
	622	for n, ax in enumerate(self.axes):	540	for n, ax in enumerate(self.axes):
	623	x, y, z = self.fill_gaps(*self.decimate())	541	x, y, z = self.fill_gaps(*self.decimate())
	624	if self.xmin is None:	542	self.zmin = self.zmin if self.zmin else numpy.min(self.z)
	625	xmin = self.min_time	543	self.zmax = self.zmax if self.zmax else numpy.max(self.z)
	626	else:
	627	xmin = fromtimestamp(int(self.xmin), self.min_time)
	628	if self.xmax is None:
	629	xmax = xmin + self.xrange6060
	630	else:
	631	xmax = xmin + (self.xmax - self.xmin) * 60 * 60
	632	self.zmin = self.zmin if self.zmin else np.min(self.z)
	633	self.zmax = self.zmax if self.zmax else np.max(self.z)
	634	if ax.firsttime:	544	if ax.firsttime:
	635	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)	545	ax.plt = ax.pcolormesh(x, y, z[n].T,
	636	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	637	plot = ax.pcolormesh(x, y, z[n].T,
	638	vmin=self.zmin,	546	vmin=self.zmin,
	639	vmax=self.zmax,	547	vmax=self.zmax,
	640	cmap=plt.get_cmap(self.colormap)	548	cmap=plt.get_cmap(self.colormap)
	641	)	549	)
	642	divider = make_axes_locatable(ax)	550	if self.showprofile:
	643	cax = divider.new_horizontal(size='2%', pad=0.05)	551	ax.plot_profile= self.pf_axes[n].plot(self.data['rti'][n][-1], self.y)[0]
	644	self.figure.add_axes(cax)	552	ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y,
	645	plt.colorbar(plot, cax)	553	color="k", linestyle="dashed", lw=1)[0]
	646	ax.set_ylim(self.ymin, self.ymax)
	647	ax.xaxis.set_major_formatter(FuncFormatter(func))
	648	ax.xaxis.set_major_locator(LinearLocator(6))
	649	ax.set_ylabel(self.ylabel)
	650	# if self.xmin is None:
	651	# xmin = self.min_time
	652	# else:
	653	# xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	654	# datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	655
	656	ax.set_xlim(xmin, xmax)
	657	ax.firsttime = False
	658	else:	554	else:
	659	ax.collections.remove(ax.collections[0])	555	ax.collections.remove(ax.collections[0])
	660	ax.set_xlim(xmin, xmax)	556	ax.plt = ax.pcolormesh(x, y, z[n].T,
	661	plot = ax.pcolormesh(x, y, z[n].T,
	662	vmin=self.zmin,
	663	vmax=self.zmax,
	664	cmap=plt.get_cmap(self.colormap)
	665	)
	666	ax.set_title('{} {}'.format(self.titles[n],
	667	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	668	size=8)
	669
	670	self.saveTime = self.min_time
	671	else :
	672	self.x = np.array(self.times)
	673	self.y = self.dataOut.getHeiRange()
	674	self.z = []
	675
	676	for ch in range(self.nrows):
	677	self.z.append([self.data[self.CODE][t][ch] for t in self.times])
	678
	679	self.z = np.array(self.z)
	680	for n, eachfigure in enumerate(self.figurelist): #estaba ax in axes
	681
	682	x, y, z = self.fill_gaps(*self.decimate())
	683	xmin = self.min_time
	684	xmax = xmin+self.xrange6060
	685	self.zmin = self.zmin if self.zmin else np.min(self.z)
	686	self.zmax = self.zmax if self.zmax else np.max(self.z)
	687	if self.axes[n].firsttime:
	688	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	689	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	690	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	691	vmin=self.zmin,
	692	vmax=self.zmax,
	693	cmap=plt.get_cmap(self.colormap)
	694	)
	695	divider = make_axes_locatable(self.axes[n])
	696	cax = divider.new_horizontal(size='2%', pad=0.05)
	697	eachfigure.add_axes(cax)
	698	#self.figure2.add_axes(cax)
	699	plt.colorbar(plot, cax)
	700	self.axes[n].set_ylim(self.ymin, self.ymax)
	701
	702	self.axes[n].xaxis.set_major_formatter(FuncFormatter(func))
	703	self.axes[n].xaxis.set_major_locator(LinearLocator(6))
	704
	705	self.axes[n].set_ylabel(self.ylabel)
	706
	707	if self.xmin is None:
	708	xmin = self.min_time
	709	else:
	710	xmin = (datetime.datetime.combine(self.dataOut.datatime.date(),
	711	datetime.time(self.xmin, 0, 0))-d1970).total_seconds()
	712
	713	self.axes[n].set_xlim(xmin, xmax)
	714	self.axes[n].firsttime = False
	715	else:
	716	self.axes[n].collections.remove(self.axes[n].collections[0])
	717	self.axes[n].set_xlim(xmin, xmax)
	718	plot = self.axes[n].pcolormesh(x, y, z[n].T,
	719	vmin=self.zmin,	557	vmin=self.zmin,
	720	vmax=self.zmax,	558	vmax=self.zmax,
	721	cmap=plt.get_cmap(self.colormap)	559	cmap=plt.get_cmap(self.colormap)
	722	)	560	)
	723	self.axes[n].set_title('{} {}'.format(self.titles[n],	561	if self.showprofile:
	724	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),	562	ax.plot_profile.set_data(self.data['rti'][n][-1], self.y)
	725	size=8)	563	ax.plot_noise.set_data(numpy.repeat(self.data['noise'][n][-1], len(self.y)), self.y)
	726		564
	727	self.saveTime = self.min_time	565	self.saveTime = self.min_time
	728		566
	729		567
	730	class PlotCOHData(PlotRTIData):	568	class PlotCOHData(PlotRTIData):
			569	'''
			570	Plot for Coherence data
			571	'''
	731		572
	732	CODE = 'coh'	573	CODE = 'coh'
	733		574
	734	def setup(self):	575	def setup(self):
	735		576	self.xaxis = 'time'
	736	self.ncols = 1	577	self.ncols = 1
	737	self.nrows = self.data~~Out~~.~~nPairs~~	578	self.nrows = len(self.data.pairs)
	738	self.width = 10	579	self.nplots = len(self.data.pairs)
	739	self.height = 2.2*self.nrows if self.nrows<6 else 12
	740	self.ind_plt_ch = False #just for coherence and phase
	741	if self.nrows==1:
	742	self.height += 1
	743	self.ylabel = 'Range [Km]'	580	self.ylabel = 'Range [Km]'
	744	self.titles = ['{} Ch{} * Ch{}'.format(self.CODE.upper(), x[0], x[1]) for x in self.dataOut.pairsList]	581	if self.CODE == 'coh':
	745		582	self.cb_label = ''
	746	if self.figure is None:	583	self.titles = ['Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	747	self.figure = plt.figure(figsize=(self.width, self.height),
	748	edgecolor='k',
	749	facecolor='w')
	750	else:	584	else:
	751	self.~~figure~~.~~clf~~()	585	self.cb_label = 'Degrees'
	752	self.axes = []	586	self.titles = ['Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
	753		587
	754	for n in range(self.nrows):	588
	755	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)	589	class PlotPHASEData(PlotCOHData):
	756	ax.firsttime = True	590	'''
	757	self.axes.append(ax)	591	Plot for Phase map data
			592	'''
			593
			594	CODE = 'phase'
			595	colormap = 'seismic'
	758		596
	759		597
	760	class PlotNoiseData(PlotData):	598	class PlotNoiseData(PlotData):
			599	'''
			600	Plot for noise
			601	'''
			602
	761	CODE = 'noise'	603	CODE = 'noise'
	762		604
	763	def setup(self):	605	def setup(self):
	764		606	self.xaxis = 'time'
	765	self.ncols = 1	607	self.ncols = 1
	766	self.nrows = 1	608	self.nrows = 1
	767	self.~~width~~ = 10	609	self.nplots = 1
	768	self.height = 3.2
	769	self.ylabel = 'Intensity [dB]'	610	self.ylabel = 'Intensity [dB]'
	770	self.titles = ['Noise']	611	self.titles = ['Noise']
	771		612	self.colorbar = False
	772	if self.figure is None:
	773	self.figure = plt.figure(figsize=(self.width, self.height),
	774	edgecolor='k',
	775	facecolor='w')
	776	else:
	777	self.figure.clf()
	778	self.axes = []
	779
	780	self.ax = self.figure.add_subplot(self.nrows, self.ncols, 1)
	781	self.ax.firsttime = True
	782
	783	def plot(self):
	784
	785	x = self.times
	786	xmin = self.min_time
	787	xmax = xmin+self.xrange6060
	788	if self.ax.firsttime:
	789	for ch in self.dataOut.channelList:
	790	y = [self.data[self.CODE][t][ch] for t in self.times]
	791	self.ax.plot(x, y, lw=1, label='Ch{}'.format(ch))
	792	self.ax.firsttime = False
	793	self.ax.xaxis.set_major_formatter(FuncFormatter(func))
	794	self.ax.xaxis.set_major_locator(LinearLocator(6))
	795	self.ax.set_ylabel(self.ylabel)
	796	plt.legend()
	797	else:
	798	for ch in self.dataOut.channelList:
	799	y = [self.data[self.CODE][t][ch] for t in self.times]
	800	self.ax.lines[ch].set_data(x, y)
	801
	802	self.ax.set_xlim(xmin, xmax)
	803	self.ax.set_ylim(min(y)-5, max(y)+5)
	804	self.saveTime = self.min_time
	805
	806
	807	class PlotWindProfilerData(PlotRTIData):
	808
	809	CODE = 'wind'
	810	colormap = 'seismic'
	811
	812	def setup(self):
	813	self.ncols = 1
	814	self.nrows = self.dataOut.data_output.shape[0]
	815	self.width = 10
	816	self.height = 2.2*self.nrows
	817	self.ylabel = 'Height [Km]'
	818	self.titles = ['Zonal Wind' ,'Meridional Wind', 'Vertical Wind']
	819	self.clabels = ['Velocity (m/s)','Velocity (m/s)','Velocity (cm/s)']
	820	self.windFactor = [1, 1, 100]
	821
	822	if self.figure is None:
	823	self.figure = plt.figure(figsize=(self.width, self.height),
	824	edgecolor='k',
	825	facecolor='w')
	826	else:
	827	self.figure.clf()
	828	self.axes = []
	829
	830	for n in range(self.nrows):
	831	ax = self.figure.add_subplot(self.nrows, self.ncols, n+1)
	832	ax.firsttime = True
	833	self.axes.append(ax)
	834		613
	835	def plot(self):	614	def plot(self):
	836		615
	837	~~self~~.x = np.~~array~~(self.times)	616	x = self.data.times
	838	self.y = self.dataOut.heightList
	839	self.z = []
	840
	841	for ch in range(self.nrows):
	842	self.z.append([self.data['output'][t][ch] for t in self.times])
	843
	844	self.z = np.array(self.z)
	845	self.z = numpy.ma.masked_invalid(self.z)
	846
	847	cmap=plt.get_cmap(self.colormap)
	848	cmap.set_bad('black', 1.)
	849
	850	for n, ax in enumerate(self.axes):
	851	x, y, z = self.fill_gaps(*self.decimate())
	852	xmin = self.min_time	617	xmin = self.min_time
	853	xmax = xmin+self.xrange6060	618	xmax = xmin+self.xrange6060
	854	if ax.firsttime:	619	Y = self.data[self.CODE]
	855	self.ymin = self.ymin if self.ymin else np.nanmin(self.y)
	856	self.ymax = self.ymax if self.ymax else np.nanmax(self.y)
	857	self.zmax = self.zmax if self.zmax else numpy.nanmax(abs(self.z[:-1, :]))
	858	self.zmin = self.zmin if self.zmin else -self.zmax
	859
	860	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],
	861	vmin=self.zmin,
	862	vmax=self.zmax,
	863	cmap=cmap
	864	)
	865	divider = make_axes_locatable(ax)
	866	cax = divider.new_horizontal(size='2%', pad=0.05)
	867	self.figure.add_axes(cax)
	868	cb = plt.colorbar(plot, cax)
	869	cb.set_label(self.clabels[n])
	870	ax.set_ylim(self.ymin, self.ymax)
	871		620
	872	ax.xaxis.set_major_formatter(FuncFormatter(func))	621	if self.axes[0].firsttime:
	873	ax.xaxis.set_major_locator(LinearLocator(6))	622	for ch in self.data.channels:
	874		623	y = Y[ch]
	875	ax.set_ylabel(self.ylabel)	624	self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
	876		625	plt.legend()
	877	ax.set_xlim(xmin, xmax)
	878	ax.firsttime = False
	879	else:	626	else:
	880	ax.collections.remove(ax.collections[0])	627	for ch in self.data.channels:
	881	ax.set_xlim(xmin, xmax)	628	y = Y[ch]
	882	plot = ax.pcolormesh(x, y, z[n].T*self.windFactor[n],	629	self.axes[0].lines[ch].set_data(x, y)
	883	vmin=self.zmin,
	884	vmax=self.zmax,
	885	cmap=plt.get_cmap(self.colormap)
	886	)
	887	ax.set_title('{} {}'.format(self.titles[n],
	888	datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')),
	889	size=8)
	890		630
			631	self.ymin = numpy.nanmin(Y) - 5
			632	self.ymax = numpy.nanmax(Y) + 5
	891	self.saveTime = self.min_time	633	self.saveTime = self.min_time
	892		634
	893		635
	894	class PlotSNRData(PlotRTIData):	636	class PlotSNRData(PlotRTIData):
			637	'''
			638	Plot for SNR Data
			639	'''
			640
	895	CODE = 'snr'	641	CODE = 'snr'
	896	colormap = 'jet'	642	colormap = 'jet'
	897		643
			644
	898	class PlotDOPData(PlotRTIData):	645	class PlotDOPData(PlotRTIData):
			646	'''
			647	Plot for DOPPLER Data
			648	'''
			649
	899	CODE = 'dop'	650	CODE = 'dop'
	900	colormap = 'jet'	651	colormap = 'jet'
	901		652
	902		653
	903	class PlotPHASEData(PlotCOHData):
	904	CODE = 'phase'
	905	colormap = 'seismic'
	906
	907
	908	class PlotSkyMapData(PlotData):	654	class PlotSkyMapData(PlotData):
			655	'''
			656	Plot for meteors detection data
			657	'''
	909		658
	910	CODE = 'met'	659	CODE = 'met'
	911		660
	912	def setup(self):	661	def setup(self):
	913		662
	914	self.ncols = 1	663	self.ncols = 1
	915	self.nrows = 1	664	self.nrows = 1
	916	self.width = 7.2	665	self.width = 7.2
	917	self.height = 7.2	666	self.height = 7.2
	918		667
	919	self.xlabel = 'Zonal Zenith Angle (deg)'	668	self.xlabel = 'Zonal Zenith Angle (deg)'
	920	self.ylabel = 'Meridional Zenith Angle (deg)'	669	self.ylabel = 'Meridional Zenith Angle (deg)'
	921		670
	922	if self.figure is None:	671	if self.figure is None:
	923	self.figure = plt.figure(figsize=(self.width, self.height),	672	self.figure = plt.figure(figsize=(self.width, self.height),
	924	edgecolor='k',	673	edgecolor='k',
	925	facecolor='w')	674	facecolor='w')
	926	else:	675	else:
	927	self.figure.clf()	676	self.figure.clf()
	928		677
	929	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)	678	self.ax = plt.subplot2grid((self.nrows, self.ncols), (0, 0), 1, 1, polar=True)
	930	self.ax.firsttime = True	679	self.ax.firsttime = True
	931		680
	932		681
	933	def plot(self):	682	def plot(self):
	934		683
	935	arrayParameters = np.concatenate([self.data['param'][t] for t in self.times])	684	arrayParameters = numpy.concatenate([self.data['param'][t] for t in self.data.times])
	936	error = arrayParameters[:,-1]	685	error = arrayParameters[:,-1]
	937	indValid = numpy.where(error == 0)[0]	686	indValid = numpy.where(error == 0)[0]
	938	finalMeteor = arrayParameters[indValid,:]	687	finalMeteor = arrayParameters[indValid,:]
	939	finalAzimuth = finalMeteor[:,3]	688	finalAzimuth = finalMeteor[:,3]
	940	finalZenith = finalMeteor[:,4]	689	finalZenith = finalMeteor[:,4]
	941		690
	942	x = finalAzimuth*numpy.pi/180	691	x = finalAzimuth*numpy.pi/180
	943	y = finalZenith	692	y = finalZenith
	944		693
	945	if self.ax.firsttime:	694	if self.ax.firsttime:
	946	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]	695	self.ax.plot = self.ax.plot(x, y, 'bo', markersize=5)[0]
	947	self.ax.set_ylim(0,90)	696	self.ax.set_ylim(0,90)
	948	self.ax.set_yticks(numpy.arange(0,90,20))	697	self.ax.set_yticks(numpy.arange(0,90,20))
	949	self.ax.set_xlabel(self.xlabel)	698	self.ax.set_xlabel(self.xlabel)
	950	self.ax.set_ylabel(self.ylabel)	699	self.ax.set_ylabel(self.ylabel)
	951	self.ax.yaxis.labelpad = 40	700	self.ax.yaxis.labelpad = 40
	952	self.ax.firsttime = False	701	self.ax.firsttime = False
	953	else:	702	else:
	954	self.ax.plot.set_data(x, y)	703	self.ax.plot.set_data(x, y)
	955		704
	956		705
	957	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')	706	dt1 = datetime.datetime.fromtimestamp(self.min_time).strftime('%y/%m/%d %H:%M:%S')
	958	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')	707	dt2 = datetime.datetime.fromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')
	959	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,	708	title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
	960	dt2,	709	dt2,
	961	len(x))	710	len(x))
	962	self.ax.set_title(title, size=8)	711	self.ax.set_title(title, size=8)
	963		712
	964	self.saveTime = self.max_time	713	self.saveTime = self.max_time
			714
			715	class PlotParamData(PlotRTIData):
			716	'''
			717	Plot for data_param object
			718	'''
			719
			720	CODE = 'param'
			721	colormap = 'seismic'
			722
			723	def setup(self):
			724	self.xaxis = 'time'
			725	self.ncols = 1
			726	self.nrows = self.data.shape(self.CODE)[0]
			727	self.nplots = self.nrows
			728	if self.showSNR:
			729	self.nrows += 1
			730
			731	self.ylabel = 'Height [Km]'
			732	self.titles = self.data.parameters \
			733	if self.data.parameters else ['Param {}'.format(x) for x in xrange(self.nrows)]
			734	if self.showSNR:
			735	self.titles.append('SNR')
			736
			737	def plot(self):
			738	self.data.normalize_heights()
			739	self.x = self.data.times
			740	self.y = self.data.heights
			741	if self.showSNR:
			742	self.z = numpy.concatenate(
			743	(self.data[self.CODE], self.data['snr'])
			744	)
			745	else:
			746	self.z = self.data[self.CODE]
			747
			748	self.z = numpy.ma.masked_invalid(self.z)
			749
			750	for n, ax in enumerate(self.axes):
			751
			752	x, y, z = self.fill_gaps(*self.decimate())
			753
			754	if ax.firsttime:
			755	if self.zlimits is not None:
			756	self.zmin, self.zmax = self.zlimits[n]
			757	self.zmax = self.zmax if self.zmax is not None else numpy.nanmax(abs(self.z[:-1, :]))
			758	self.zmin = self.zmin if self.zmin is not None else -self.zmax
			759	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			760	vmin=self.zmin,
			761	vmax=self.zmax,
			762	cmap=self.cmaps[n]
			763	)
			764	else:
			765	if self.zlimits is not None:
			766	self.zmin, self.zmax = self.zlimits[n]
			767	ax.collections.remove(ax.collections[0])
			768	ax.plt = ax.pcolormesh(x, y, z[n, :, :].T*self.factors[n],
			769	vmin=self.zmin,
			770	vmax=self.zmax,
			771	cmap=self.cmaps[n]
			772	)
			773
			774	self.saveTime = self.min_time
			775
			776	class PlotOuputData(PlotParamData):
			777	'''
			778	Plot data_output object
			779	'''
			780
			781	CODE = 'output'
			782	colormap = 'seismic' No newline at end of file

schainpy/model/proc/jroproc_parameters.py 0 0

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

schainpy/model/proc/jroproc_spectra.py +16 -17

+            import itertools
             import numpy
             from jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import Spectra
             from schainpy.model.data.jrodata import hildebrand_sekhon
             class SpectraProc(ProcessingUnit):
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     self.buffer = None
                     self.firstdatatime = None
                     self.profIndex = 0
                     self.dataOut = Spectra()
                     self.id_min = None
                     self.id_max = None
                 def __updateSpecFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
                     self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
                     self.dataOut.flagShiftFFT = False
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.realtime = self.dataIn.realtime
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                         self.profIndex
                         self.buffer
                         self.dataOut.flagNoData
                     """
                     fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
                     fft_volt = fft_volt.astype(numpy.dtype('complex'))
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = fft_volt * numpy.conjugate(fft_volt)
                     spc = spc.real
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.dataOut.pairsList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
                         for pair in self.dataOut.pairsList:
                             if pair[0] not in self.dataOut.channelList:
                                 raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
                             if pair[1] not in self.dataOut.channelList:
                                 raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
                             cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOut.data_spc = spc
                     self.dataOut.data_cspc = cspc
                     self.dataOut.data_dc = dc
                     self.dataOut.blockSize = blocksize
                     self.dataOut.flagShiftFFT = True
                 def run(self, nProfiles=None, nFFTPoints=None, pairsList=[], ippFactor=None):
                     self.dataOut.flagNoData = True
                     if self.dataIn.type == "Spectra":
                         self.dataOut.copy(self.dataIn)
-            #             self.__selectPairs(pairsList)
+                        if not pairsList:
+                            pairsList = itertools.combinations(self.dataOut.channelList, 2)
+                        if self.dataOut.data_cspc is not None:
+                            self.__selectPairs(pairsList)
                         return True
                     if self.dataIn.type == "Voltage":
                         if nFFTPoints == None:
                             raise ValueError, "This SpectraProc.run() need nFFTPoints input variable"
                         if nProfiles == None:
                             nProfiles = nFFTPoints
                         if ippFactor == None:
                             ippFactor = 1
                         self.dataOut.ippFactor = ippFactor
                         self.dataOut.nFFTPoints = nFFTPoints
                         self.dataOut.pairsList = pairsList
                         if self.buffer is None:
                             self.buffer = numpy.zeros( (self.dataIn.nChannels,
                                                         nProfiles,
                                                         self.dataIn.nHeights),
                                                       dtype='complex')
                         if self.dataIn.flagDataAsBlock:
                             #data dimension: [nChannels, nProfiles, nSamples]
                             nVoltProfiles = self.dataIn.data.shape[1]
             #                 nVoltProfiles = self.dataIn.nProfiles
                             if nVoltProfiles == nProfiles:
                                 self.buffer = self.dataIn.data.copy()
                                 self.profIndex = nVoltProfiles
                             elif nVoltProfiles < nProfiles:
                                 if self.profIndex == 0:
                                     self.id_min = 0
                                     self.id_max = nVoltProfiles
                                 self.buffer[:,self.id_min:self.id_max,:] = self.dataIn.data
                                 self.profIndex += nVoltProfiles
                                 self.id_min += nVoltProfiles
                                 self.id_max += nVoltProfiles
                             else:
                                 raise ValueError, "The type object %s has %d profiles, it should just has %d profiles"%(self.dataIn.type,self.dataIn.data.shape[1],nProfiles)
                                 self.dataOut.flagNoData = True
                                 return 0
                         else:
                             self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
                             self.profIndex += 1
                         if self.firstdatatime == None:
                             self.firstdatatime = self.dataIn.utctime
                         if self.profIndex == nProfiles:
                             self.__updateSpecFromVoltage()
                             self.__getFft()
                             self.dataOut.flagNoData = False
                             self.firstdatatime = None
                             self.profIndex = 0
                         return True
                     raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
                 def __selectPairs(self, pairsList):
-                    if channelList == None:
+                    if not pairsList:
                         return
-                    pairsIndexListSelected = []
+                    pairs = []
+                    pairsIndex = []
-                    for thisPair in pairsList:
-                        if thisPair not in self.dataOut.pairsList:
+                    for pair in pairsList:
+                        if pair[0] not in self.dataOut.channelList or pair[1] not in self.dataOut.channelList:
                             continue
+                        pairs.append(pair)
+                        pairsIndex.append(pairs.index(pair))
-                        pairIndex = self.dataOut.pairsList.index(thisPair)
+                    self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
+                    self.dataOut.pairsList = pairs
-                        pairsIndexListSelected.append(pairIndex)
+                    self.dataOut.pairsIndexList = pairsIndex
-                    if not pairsIndexListSelected:
-                        self.dataOut.data_cspc = None
-                        self.dataOut.pairsList = []
-                        return
-                    self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
-                    self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
                     return
                 def __selectPairsByChannel(self, channelList=None):
                     if channelList == None:
                         return
                     pairsIndexListSelected = []
                     for pairIndex in self.dataOut.pairsIndexList:
                         #First pair
                         if self.dataOut.pairsList[pairIndex][0] not in channelList:
                             continue
                         #Second pair
                         if self.dataOut.pairsList[pairIndex][1] not in channelList:
                             continue
                         pairsIndexListSelected.append(pairIndex)
                     if not pairsIndexListSelected:
                         self.dataOut.data_cspc = None
                         self.dataOut.pairsList = []
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
                     self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
                     return
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
             #         nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     data_dc = self.dataOut.data_dc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
             #        self.dataOut.nChannels = nChannels
                     self.__selectPairsByChannel(self.dataOut.channelList)
                     return 1
                 def selectHeights(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minHei > maxHei):
                         raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
                     if (minHei < self.dataOut.heightList[0]):
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]):
                         maxHei = self.dataOut.heightList[-1]
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def getBeaconSignal(self, tauindex = 0, channelindex = 0, hei_ref=None):
                     newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
                     if hei_ref != None:
                         newheis = numpy.where(self.dataOut.heightList>hei_ref)
                     minIndex = min(newheis[0])
                     maxIndex = max(newheis[0])
                     data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
                     heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                     # determina indices
                     nheis = int(self.dataOut.radarControllerHeaderObj.txB/(self.dataOut.heightList[1]-self.dataOut.heightList[0]))
                     avg_dB = 10*numpy.log10(numpy.sum(data_spc[channelindex,:,:],axis=0))
                     beacon_dB = numpy.sort(avg_dB)[-nheis:]
                     beacon_heiIndexList = []
                     for val in avg_dB.tolist():
                         if val >= beacon_dB[0]:
                             beacon_heiIndexList.append(avg_dB.tolist().index(val))
                     #data_spc = data_spc[:,:,beacon_heiIndexList]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
                         #data_cspc = data_cspc[:,:,beacon_heiIndexList]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
                         #data_dc = data_dc[:,beacon_heiIndexList]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = heightList
                     self.dataOut.beacon_heiIndexList = beacon_heiIndexList
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data_spc
                         self.dataOut.data_cspc
                         self.dataOut.data_dc
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     #Spectra
                     data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
                     data_cspc = None
                     if self.dataOut.data_cspc is not None:
                         data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
                     data_dc = None
                     if self.dataOut.data_dc is not None:
                         data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.data_cspc = data_cspc
                     self.dataOut.data_dc = data_dc
                     self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
                     return 1
                 def removeDC(self, mode = 2):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     if jcspectra is not None:
                         jcspectraExist = True
                         num_pairs = jcspectra.shape[0]
                     else:   jcspectraExist = False
                     freq_dc = jspectra.shape[1]/2
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
                         ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                         if jcspectraExist:
                             jcspectra[:,freq_dc,:] = (jcspectra[:,ind_vel[1],:] + jcspectra[:,ind_vel[2],:])/2
                     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(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
                         if jcspectraExist:
                             for ip in range(num_pairs):
                                 yy = jcspectra[ip,ind_vel,:]
                                 jcspectra[ip,freq_dc,:] = numpy.dot(xx_aux,yy)
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def removeInterference(self,  interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None):
                     jspectra = self.dataOut.data_spc
                     jcspectra = self.dataOut.data_cspc
                     jnoise = self.dataOut.getNoise()
                     num_incoh = self.dataOut.nIncohInt
                     num_channel  = jspectra.shape[0]
                     num_prof  = jspectra.shape[1]
                     num_hei   = jspectra.shape[2]
                     #hei_interf
                     if hei_interf is None:
                         count_hei = num_hei/2   #Como es entero no importa
                         hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
                         hei_interf = numpy.asarray(hei_interf)[0]
                     #nhei_interf
                     if (nhei_interf == None):
                         nhei_interf = 5
                     if (nhei_interf < 1):
                         nhei_interf = 1
                     if (nhei_interf > count_hei):
                         nhei_interf = count_hei
                     if (offhei_interf == None):
                         offhei_interf = 0
                     ind_hei = range(num_hei)
             #         mask_prof = numpy.asarray(range(num_prof - 2)) + 1
             #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
                     mask_prof = numpy.asarray(range(num_prof))
                     num_mask_prof = mask_prof.size
                     comp_mask_prof = [0, num_prof/2]
                     #noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
                     if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
                         jnoise = numpy.nan
                     noise_exist = jnoise[0] < numpy.Inf
                     #Subrutina de Remocion de la Interferencia
                     for ich in range(num_channel):
                         #Se ordena los espectros segun su potencia (menor a mayor)
                         power = jspectra[ich,mask_prof,:]
                         power = power[:,hei_interf]
                         power = power.sum(axis = 0)
                         psort = power.ravel().argsort()
                         #Se estima la interferencia promedio en los Espectros de Potencia empleando
                         junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
                         if noise_exist:
                         #    tmp_noise = jnoise[ich] / num_prof
                             tmp_noise = jnoise[ich]
                         junkspc_interf = junkspc_interf - tmp_noise
                         #junkspc_interf[:,comp_mask_prof] = 0
                         jspc_interf = junkspc_interf.sum(axis = 0) / nhei_interf
                         jspc_interf = jspc_interf.transpose()
                         #Calculando el espectro de interferencia promedio
                         noiseid =  numpy.where(jspc_interf <= tmp_noise/ numpy.sqrt(num_incoh))
                         noiseid = noiseid[0]
                         cnoiseid = noiseid.size
                         interfid = numpy.where(jspc_interf > tmp_noise/ numpy.sqrt(num_incoh))
                         interfid = interfid[0]
                         cinterfid = interfid.size
                         if (cnoiseid > 0):   jspc_interf[noiseid] = 0
                         #Expandiendo los perfiles a limpiar
                         if (cinterfid > 0):
                             new_interfid = (numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof)%num_prof
                             new_interfid = numpy.asarray(new_interfid)
                             new_interfid = {x for x in new_interfid}
                             new_interfid = numpy.array(list(new_interfid))
                             new_cinterfid = new_interfid.size
                         else: new_cinterfid = 0
                         for ip in range(new_cinterfid):
                             ind = junkspc_interf[:,new_interfid[ip]].ravel().argsort()
                             jspc_interf[new_interfid[ip]] = junkspc_interf[ind[nhei_interf/2],new_interfid[ip]]
                         jspectra[ich,:,ind_hei] = jspectra[ich,:,ind_hei] - jspc_interf #Corregir indices
                         #Removiendo la interferencia del punto de mayor interferencia
                         ListAux = jspc_interf[mask_prof].tolist()
                         maxid = ListAux.index(max(ListAux))
                         if cinterfid > 0:
                             for ip in range(cinterfid*(interf == 2) - 1):
                                 ind = (jspectra[ich,interfid[ip],:] < tmp_noise*(1 + 1/numpy.sqrt(num_incoh))).nonzero()
                                 cind = len(ind)
                                 if (cind > 0):
                                     jspectra[ich,interfid[ip],ind] = tmp_noise*(1 + (numpy.random.uniform(cind) - 0.5)/numpy.sqrt(num_incoh))
                             ind = numpy.array([-2,-1,1,2])
                             xx = numpy.zeros([4,4])
                             for id1 in range(4):
                                 xx[:,id1] = ind[id1]**numpy.asarray(range(4))
                             xx_inv = numpy.linalg.inv(xx)
                             xx = xx_inv[:,0]
                             ind = (ind + maxid + num_mask_prof)%num_mask_prof
                             yy = jspectra[ich,mask_prof[ind],:]
                             jspectra[ich,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
                         indAux = (jspectra[ich,:,:] < tmp_noise*(1-1/numpy.sqrt(num_incoh))).nonzero()
                         jspectra[ich,indAux[0],indAux[1]] = tmp_noise * (1 - 1/numpy.sqrt(num_incoh))
                     #Remocion de Interferencia en el Cross Spectra
                     if jcspectra is None: return jspectra, jcspectra
                     num_pairs = jcspectra.size/(num_prof*num_hei)
                     jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
                     for ip in range(num_pairs):
                         #-------------------------------------------
                         cspower = numpy.abs(jcspectra[ip,mask_prof,:])
                         cspower = cspower[:,hei_interf]
                         cspower = cspower.sum(axis = 0)
                         cspsort = cspower.ravel().argsort()
                         junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
                         junkcspc_interf = junkcspc_interf.transpose()
                         jcspc_interf = junkcspc_interf.sum(axis = 1)/nhei_interf
                         ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
                         median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
                         median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
                         junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
                         for iprof in range(num_prof):
                             ind = numpy.abs(junkcspc_interf[iprof,:]).ravel().argsort()
                             jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf/2]]
                         #Removiendo la Interferencia
                         jcspectra[ip,:,ind_hei] = jcspectra[ip,:,ind_hei] - jcspc_interf
                         ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
                         maxid = ListAux.index(max(ListAux))
                         ind = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for id1 in range(4):
                             xx[:,id1] = ind[id1]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx = xx_inv[:,0]
                         ind = (ind + maxid + num_mask_prof)%num_mask_prof
                         yy = jcspectra[ip,mask_prof[ind],:]
                         jcspectra[ip,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
                     #Guardar Resultados
                     self.dataOut.data_spc = jspectra
                     self.dataOut.data_cspc = jcspectra
                     return 1
                 def setRadarFrequency(self, frequency=None):
                     if frequency != None:
                         self.dataOut.frequency = frequency
                     return 1
                 def getNoise(self, minHei=None, maxHei=None, minVel=None, maxVel=None):
                     #validacion de rango
                     if minHei == None:
                         minHei = self.dataOut.heightList[0]
                     if maxHei == None:
                         maxHei = self.dataOut.heightList[-1]
                     if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
                         print 'minHei: %.2f is out of the heights range'%(minHei)
                         print 'minHei is setting to %.2f'%(self.dataOut.heightList[0])
                         minHei = self.dataOut.heightList[0]
                     if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
                         print 'maxHei: %.2f is out of the heights range'%(maxHei)
                         print 'maxHei is setting to %.2f'%(self.dataOut.heightList[-1])
                         maxHei = self.dataOut.heightList[-1]
                     # validacion de velocidades
                     velrange = self.dataOut.getVelRange(1)
                     if minVel == None:
                         minVel = velrange[0]
                     if maxVel == None:
                         maxVel = velrange[-1]
                     if (minVel < velrange[0]) or (minVel > maxVel):
                         print 'minVel: %.2f is out of the velocity range'%(minVel)
                         print 'minVel is setting to %.2f'%(velrange[0])
                         minVel = velrange[0]
                     if (maxVel > velrange[-1]) or (maxVel < minVel):
                         print 'maxVel: %.2f is out of the velocity range'%(maxVel)
                         print 'maxVel is setting to %.2f'%(velrange[-1])
                         maxVel = velrange[-1]
                     # seleccion de indices para rango
                     minIndex = 0
                     maxIndex = 0
                     heights = self.dataOut.heightList
                     inda = numpy.where(heights >= minHei)
                     indb = numpy.where(heights <= maxHei)
                     try:
                         minIndex = inda[0][0]
                     except:
                         minIndex = 0
                     try:
                         maxIndex = indb[0][-1]
                     except:
                         maxIndex = len(heights)
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOut.nHeights):
                         maxIndex = self.dataOut.nHeights-1
                     # seleccion de indices para velocidades
                     indminvel = numpy.where(velrange >= minVel)
                     indmaxvel = numpy.where(velrange <= maxVel)
                     try:
                         minIndexVel = indminvel[0][0]
                     except:
                         minIndexVel = 0
                     try:
                         maxIndexVel = indmaxvel[0][-1]
                     except:
                         maxIndexVel = len(velrange)
                     #seleccion del espectro
                     data_spc = self.dataOut.data_spc[:,minIndexVel:maxIndexVel+1,minIndex:maxIndex+1]
                     #estimacion de ruido
                     noise = numpy.zeros(self.dataOut.nChannels)
                     for channel in range(self.dataOut.nChannels):
                         daux = data_spc[channel,:,:]
                         noise[channel] = hildebrand_sekhon(daux, self.dataOut.nIncohInt)
                     self.dataOut.noise_estimation = noise.copy()
                     return 1
             class IncohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer_spc = None
                 __buffer_cspc = None
                 __buffer_dc = None
                 __dataReady = False
                 __timeInterval = None
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
             #         self.isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     self.__dataReady = False
                     self.__byTime = False
                     if n is None and timeInterval is None:
                         raise ValueError, "n or timeInterval should be specified ..."
                     if n is not None:
                         self.n = int(n)
                     else:
                         self.__integrationtime = int(timeInterval) #if (type(timeInterval)!=integer) -> change this line
                         self.n = None
                         self.__byTime = True
                 def putData(self, data_spc, data_cspc, data_dc):
                     """
                     Add a profile to the __buffer_spc and increase in one the __profileIndex
                     """
                     self.__buffer_spc += data_spc
                     if data_cspc is None:
                         self.__buffer_cspc = None
                     else:
                         self.__buffer_cspc += data_cspc
                     if data_dc is None:
                         self.__buffer_dc = None
                     else:
                         self.__buffer_dc += data_dc
                     self.__profIndex += 1
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     data_spc = self.__buffer_spc
                     data_cspc = self.__buffer_cspc
                     data_dc = self.__buffer_dc
                     n = self.__profIndex
                     self.__buffer_spc = 0
                     self.__buffer_cspc = 0
                     self.__buffer_dc = 0
                     self.__profIndex = 0
                     return data_spc, data_cspc, data_dc, n
                 def byProfiles(self, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if self.__profIndex == self.n:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def byTime(self, datatime, *args):
                     self.__dataReady = False
                     avgdata_spc = None
                     avgdata_cspc = None
                     avgdata_dc = None
                     self.putData(*args)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata_spc, avgdata_cspc, avgdata_dc, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata_spc, avgdata_cspc, avgdata_dc
                 def integrate(self, datatime, *args):
                     if self.__profIndex == 0:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
                     else:
                         avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
                     if not self.__dataReady:
                         return None, None, None, None
                     return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
                     if n==1:
                         return
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(n, timeInterval, overlapping)
                         self.isConfig = True
                     avgdatatime, avgdata_spc, avgdata_cspc, avgdata_dc = self.integrate(dataOut.utctime,
                                                                                         dataOut.data_spc,
                                                                                         dataOut.data_cspc,
                                                                                         dataOut.data_dc)
                     if self.__dataReady:
                         dataOut.data_spc = avgdata_spc
                         dataOut.data_cspc = avgdata_cspc
                         dataOut.data_dc = avgdata_dc
                         dataOut.nIncohInt *= self.n
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False

schainpy/model/utils/jroutils_publish.py +205 -102

             '''
             @author: Juan C. Espinoza
             '''
             import time
             import json
             import numpy
             import paho.mqtt.client as mqtt
             import zmq
             import datetime
             from zmq.utils.monitor import recv_monitor_message
             from functools import wraps
             from threading import Thread
             from multiprocessing import Process
             from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
             from schainpy.model.data.jrodata import JROData
+            from schainpy.utils import log
             MAXNUMX = 100
             MAXNUMY = 100
             class PrettyFloat(float):
                 def __repr__(self):
                     return '%.2f' % self
             def roundFloats(obj):
                 if isinstance(obj, list):
                     return map(roundFloats, obj)
                 elif isinstance(obj, float):
                     return round(obj, 2)
             def decimate(z, MAXNUMY):
-                # dx = int(len(self.x)/self.__MAXNUMX) + 1
                 dy = int(len(z[0])/MAXNUMY) + 1
                 return z[::, ::dy]
             class throttle(object):
-                """Decorator that prevents a function from being called more than once every
+                '''
+                Decorator that prevents a function from being called more than once every
                 time period.
                 To create a function that cannot be called more than once a minute, but
                 will sleep until it can be called:
                 @throttle(minutes=1)
                 def foo():
                   pass
                 for i in range(10):
                   foo()
                   print "This function has run %s times." % i
-                """
+                '''
                 def __init__(self, seconds=0, minutes=0, hours=0):
                     self.throttle_period = datetime.timedelta(
                         seconds=seconds, minutes=minutes, hours=hours
                     )
                     self.time_of_last_call = datetime.datetime.min
                 def __call__(self, fn):
                     @wraps(fn)
                     def wrapper(*args, **kwargs):
                         now = datetime.datetime.now()
                         time_since_last_call = now - self.time_of_last_call
                         time_left = self.throttle_period - time_since_last_call
                         if time_left > datetime.timedelta(seconds=0):
                             return
                         self.time_of_last_call = datetime.datetime.now()
                         return fn(*args, **kwargs)
                     return wrapper
+            class Data(object):
+                '''
+                Object to hold data to be plotted
+                '''
+                def __init__(self, plottypes, throttle_value):
+                    self.plottypes = plottypes
+                    self.throttle = throttle_value
+                    self.ended = False
+                    self.__times = []
+                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:
+                        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 setup(self):
+                    '''
+                    Configure object
+                    '''
+                    self.ended = False
+                    self.data = {}
+                    self.__times = []
+                    self.__heights = []
+                    self.__all_heights = set()
+                    for plot in self.plottypes:
+                        self.data[plot] = {}
+                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:
+                            return self.data[key].shape
+                        return self.data[key][self.__times[0]].shape
+                    return (0,)
+                def update(self, dataOut):
+                    '''
+                    Update data object with new dataOut
+                    '''
+                    tm = dataOut.utctime
+                    if tm in self.__times:
+                        return
+                    self.parameters = getattr(dataOut, 'parameters', [])
+                    self.pairs = dataOut.pairsList
+                    self.channels = dataOut.channelList
+                    self.xrange = (dataOut.getFreqRange(1)/1000. , dataOut.getAcfRange(1) , dataOut.getVelRange(1))
+                    self.interval = dataOut.getTimeInterval()
+                    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
+                            self.data[plot] = 10*numpy.log10(z)
+                        if plot == 'cspc':
+                            self.data[plot] = dataOut.data_cspc
+                        if plot == 'noise':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
+                        if plot == 'rti':
+                            self.data[plot][tm] = dataOut.getPower()
+                        if plot == 'snr_db':
+                            self.data['snr'][tm] = dataOut.data_SNR
+                        if plot == 'snr':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.data_SNR)
+                        if plot == 'dop':
+                            self.data[plot][tm] = 10*numpy.log10(dataOut.data_DOP)
+                        if plot == 'mean':
+                            self.data[plot][tm] = dataOut.data_MEAN
+                        if plot == 'std':
+                            self.data[plot][tm] = dataOut.data_STD
+                        if plot == 'coh':
+                            self.data[plot][tm] = dataOut.getCoherence()
+                        if plot == 'phase':
+                            self.data[plot][tm] = dataOut.getCoherence(phase=True)
+                        if plot == 'output':
+                            self.data[plot][tm] = dataOut.data_output
+                        if plot == 'param':
+                            self.data[plot][tm] = dataOut.data_param
+                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 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
+                    '''
+                    ret = {}
+                    tm = self.times[-1]
+                    for key, value in self.data:
+                        if key in ('spc', 'cspc'):
+                            ret[key] = roundFloats(self.data[key].to_list())
+                        else:
+                            ret[key] = roundFloats(self.data[key][tm].to_list())
+                    ret['timestamp'] = tm
+                    ret['interval'] = self.interval
+                @property
+                def times(self):
+                    '''
+                    Return the list of times of the current data
+                    '''
+                    ret = numpy.array(self.__times)
+                    ret.sort()
+                    return ret
+                @property
+                def heights(self):
+                    '''
+                    Return the list of heights of the current data
+                    '''
+                    return numpy.array(self.__heights[-1])
             class PublishData(Operation):
-                """Clase publish."""
+                '''
+                Operation to send data over zmq.
+                '''
                 def __init__(self, **kwargs):
                     """Inicio."""
                     Operation.__init__(self, **kwargs)
                     self.isConfig = False
                     self.client = None
                     self.zeromq = None
                     self.mqtt = None
                 def on_disconnect(self, client, userdata, rc):
                     if rc != 0:
-                        print("Unexpected disconnection.")
+                        log.warning('Unexpected disconnection.')
                     self.connect()
                 def connect(self):
-                    print 'trying to connect'
+                    log.warning('trying to connect')
                     try:
                         self.client.connect(
                             host=self.host,
                             port=self.port,
                             keepalive=60*10,
                             bind_address='')
                         self.client.loop_start()
                         # self.client.publish(
                         #     self.topic + 'SETUP',
                         #     json.dumps(setup),
                         #     retain=True
                         #     )
                     except:
-                        print "MQTT Conection error."
+                        log.error('MQTT Conection error.')
                         self.client = False
                 def setup(self, port=1883, username=None, password=None, clientId="user", zeromq=1, verbose=True, **kwargs):
                     self.counter = 0
                     self.topic = kwargs.get('topic', 'schain')
                     self.delay = kwargs.get('delay', 0)
                     self.plottype = kwargs.get('plottype', 'spectra')
                     self.host = kwargs.get('host', "10.10.10.82")
                     self.port = kwargs.get('port', 3000)
                     self.clientId = clientId
                     self.cnt = 0
                     self.zeromq = zeromq
                     self.mqtt = kwargs.get('plottype', 0)
                     self.client = None
                     self.verbose = verbose
-                    self.dataOut.firstdata = True
                     setup = []
                     if mqtt is 1:
                         self.client = mqtt.Client(
                             client_id=self.clientId + self.topic + 'SCHAIN',
                             clean_session=True)
                         self.client.on_disconnect = self.on_disconnect
                         self.connect()
                         for plot in self.plottype:
                             setup.append({
                                 'plot': plot,
                                 'topic': self.topic + plot,
                                 'title': getattr(self, plot + '_' + 'title', False),
                                 'xlabel': getattr(self, plot + '_' + 'xlabel', False),
                                 'ylabel': getattr(self, plot + '_' + 'ylabel', False),
                                 'xrange': getattr(self, plot + '_' + 'xrange', False),
                                 'yrange': getattr(self, plot + '_' + 'yrange', False),
                                 'zrange': getattr(self, plot + '_' + 'zrange', False),
                             })
                     if zeromq is 1:
                         context = zmq.Context()
                         self.zmq_socket = context.socket(zmq.PUSH)
                         server = kwargs.get('server', 'zmq.pipe')
                         if 'tcp://' in server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % server
                         self.zmq_socket.connect(address)
                         time.sleep(1)
                 def publish_data(self):
                     self.dataOut.finished = False
                     if self.mqtt is 1:
                         yData = self.dataOut.heightList[:2].tolist()
                         if self.plottype == 'spectra':
                             data = getattr(self.dataOut, 'data_spc')
                             z = data/self.dataOut.normFactor
                             zdB = 10*numpy.log10(z)
                             xlen, ylen = zdB[0].shape
                             dx = int(xlen/MAXNUMX) + 1
                             dy = int(ylen/MAXNUMY) + 1
                             Z = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 Z[i] = zdB[i][::dx, ::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(Z),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
-                            # print payload
                         elif self.plottype in ('rti', 'power'):
                             data = getattr(self.dataOut, 'data_spc')
                             z = data/self.dataOut.normFactor
                             avg = numpy.average(z, axis=1)
                             avgdB = 10*numpy.log10(avg)
                             xlen, ylen = z[0].shape
                             dy = numpy.floor(ylen/self.__MAXNUMY) + 1
                             AVG = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 AVG[i] = avgdB[i][::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(AVG),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         elif self.plottype == 'noise':
                             noise = self.dataOut.getNoise()/self.dataOut.normFactor
                             noisedB = 10*numpy.log10(noise)
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(noisedB.reshape(-1, 1).tolist()),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'interval': self.dataOut.getTimeInterval(),
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         elif self.plottype == 'snr':
                             data = getattr(self.dataOut, 'data_SNR')
                             avgdB = 10*numpy.log10(data)
                             ylen = data[0].size
                             dy = numpy.floor(ylen/self.__MAXNUMY) + 1
                             AVG = [0 for i in self.dataOut.channelList]
                             for i in self.dataOut.channelList:
                                 AVG[i] = avgdB[i][::dy].tolist()
                             payload = {
                                 'timestamp': self.dataOut.utctime,
                                 'data': roundFloats(AVG),
                                 'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                                 'type': self.plottype,
                                 'yData': yData
                             }
                         else:
                             print "Tipo de grafico invalido"
                             payload = {
                                 'data': 'None',
                                 'timestamp': 'None',
                                 'type': None
                             }
-                            # print 'Publishing data to {}'.format(self.host)
                         self.client.publish(self.topic + self.plottype, json.dumps(payload), qos=0)
                     if self.zeromq is 1:
                         if self.verbose:
-                            print '[Sending] {} - {}'.format(self.dataOut.type, self.dataOut.datatime)
+                            log.log(
+                                '{} - {}'.format(self.dataOut.type, self.dataOut.datatime),
+                                'Sending'
+                            )
                         self.zmq_socket.send_pyobj(self.dataOut)
-                        self.dataOut.firstdata = False
                 def run(self, dataOut, **kwargs):
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.publish_data()
                     time.sleep(self.delay)
                 def close(self):
                     if self.zeromq is 1:
                         self.dataOut.finished = True
                         self.zmq_socket.send_pyobj(self.dataOut)
+                        time.sleep(0.1)
                         self.zmq_socket.close()
                     if self.client:
                         self.client.loop_stop()
                         self.client.disconnect()
             class ReceiverData(ProcessingUnit):
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     self.isConfig = False
                     server = kwargs.get('server', 'zmq.pipe')
                     if 'tcp://' in server:
                         address = server
                     else:
                         address = 'ipc:///tmp/%s' % server
                     self.address = address
                     self.dataOut = JROData()
                 def setup(self):
                     self.context = zmq.Context()
                     self.receiver = self.context.socket(zmq.PULL)
                     self.receiver.bind(self.address)
                     time.sleep(0.5)
-                    print '[Starting] ReceiverData from {}'.format(self.address)
+                    log.success('ReceiverData from {}'.format(self.address))
                 def run(self):
                     if not self.isConfig:
                         self.setup()
                         self.isConfig = True
                     self.dataOut = self.receiver.recv_pyobj()
-                    print '[Receiving] {} - {}'.format(self.dataOut.type,
+                    log.log('{} - {}'.format(self.dataOut.type,
-                                                           self.dataOut.datatime.ctime())
+                                             self.dataOut.datatime.ctime(),),
+                            'Receiving')
             class PlotterReceiver(ProcessingUnit, Process):
                 throttle_value = 5
                 def __init__(self, **kwargs):
                     ProcessingUnit.__init__(self, **kwargs)
                     Process.__init__(self)
                     self.mp = False
                     self.isConfig = False
                     self.isWebConfig = False
-                    self.plottypes = []
                     self.connections = 0
                     server = kwargs.get('server', 'zmq.pipe')
                     plot_server = kwargs.get('plot_server', 'zmq.web')
                     if 'tcp://' in server:
                         address = server
                     else:
                         address = 'ipc:///tmp/%s' % server
                     if 'tcp://' in plot_server:
                         plot_address = plot_server
                     else:
                         plot_address = 'ipc:///tmp/%s' % plot_server
                     self.address = address
                     self.plot_address = plot_address
                     self.plottypes = [s.strip() for s in kwargs.get('plottypes', 'rti').split(',')]
                     self.realtime = kwargs.get('realtime', False)
                     self.throttle_value = kwargs.get('throttle', 5)
                     self.sendData = self.initThrottle(self.throttle_value)
+                    self.dates = []
                     self.setup()
                 def setup(self):
-                    self.data = {}
+                    self.data = Data(self.plottypes, self.throttle_value)
-                    self.data['times'] = []
-                    for plottype in self.plottypes:
-                        self.data[plottype] = {}
-                    self.data['noise'] = {}
-                    self.data['throttle'] = self.throttle_value
-                    self.data['ENDED'] = False
                     self.isConfig = True
-                    self.data_web = {}
                 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
-                        if self.connections == 0 and self.started is True:
-                            self.ended = True
                         evt.update({'description': events[evt['event']]})
                         if evt['event'] == zmq.EVENT_MONITOR_STOPPED:
                             break
                     monitor.close()
-                    print("event monitor thread done!")
+                    print('event monitor thread done!')
                 def initThrottle(self, throttle_value):
                     @throttle(seconds=throttle_value)
                     def sendDataThrottled(fn_sender, data):
                         fn_sender(data)
                     return sendDataThrottled
                 def send(self, data):
-                    # print '[sending] data=%s size=%s' % (data.keys(), len(data['times']))
+                    log.success('Sending {}'.format(data), self.name)
                     self.sender.send_pyobj(data)
-                def update(self):
-                    t = self.dataOut.utctime
-                    if t in self.data['times']:
-                        return
-                    self.data['times'].append(t)
-                    self.data['dataOut'] = self.dataOut
-                    for plottype in self.plottypes:
-                        if plottype == 'spc':
-                            z = self.dataOut.data_spc/self.dataOut.normFactor
-                            self.data[plottype] = 10*numpy.log10(z)
-                            self.data['noise'][t] = 10*numpy.log10(self.dataOut.getNoise()/self.dataOut.normFactor)
-                        if plottype == 'cspc':
-                            jcoherence = self.dataOut.data_cspc/numpy.sqrt(self.dataOut.data_spc*self.dataOut.data_spc)
-                            self.data['cspc_coh'] = numpy.abs(jcoherence)
-                            self.data['cspc_phase'] = numpy.arctan2(jcoherence.imag, jcoherence.real)*180/numpy.pi
-                        if plottype == 'rti':
-                            self.data[plottype][t] = self.dataOut.getPower()
-                        if plottype == 'snr':
-                            self.data[plottype][t] = 10*numpy.log10(self.dataOut.data_SNR)
-                        if plottype == 'dop':
-                            self.data[plottype][t] = 10*numpy.log10(self.dataOut.data_DOP)
-                        if plottype == 'mean':
-                            self.data[plottype][t] = self.dataOut.data_MEAN
-                        if plottype == 'std':
-                            self.data[plottype][t] = self.dataOut.data_STD
-                        if plottype == 'coh':
-                            self.data[plottype][t] = self.dataOut.getCoherence()
-                        if plottype == 'phase':
-                            self.data[plottype][t] = self.dataOut.getCoherence(phase=True)
-                        if plottype == 'output':
-                            self.data[plottype][t] = self.dataOut.data_output
-                        if plottype == 'param':
-                            self.data[plottype][t] = self.dataOut.data_param
-                        if self.realtime:
-                            self.data_web['timestamp'] = t
-                            if plottype == 'spc':
-                                self.data_web[plottype] = roundFloats(decimate(self.data[plottype]).tolist())
-                            elif plottype == 'cspc':
-                                self.data_web['cspc_coh'] = roundFloats(decimate(self.data['cspc_coh']).tolist())
-                                self.data_web['cspc_phase'] = roundFloats(decimate(self.data['cspc_phase']).tolist())
-                            elif plottype == 'noise':
-                                self.data_web['noise'] = roundFloats(self.data['noise'][t].tolist())
-                            else:
-                                self.data_web[plottype] = roundFloats(decimate(self.data[plottype][t]).tolist())
-                            self.data_web['interval'] = self.dataOut.getTimeInterval()
-                            self.data_web['type'] = plottype
                 def run(self):
-                    print '[Starting] {} from {}'.format(self.name, self.address)
+                    log.success(
+                        'Starting from {}'.format(self.address),
+                        self.name
+                    )
                     self.context = zmq.Context()
                     self.receiver = self.context.socket(zmq.PULL)
                     self.receiver.bind(self.address)
                     monitor = self.receiver.get_monitor_socket()
                     self.sender = self.context.socket(zmq.PUB)
                     if self.realtime:
                         self.sender_web = self.context.socket(zmq.PUB)
                         self.sender_web.connect(self.plot_address)
                         time.sleep(1)
                     if 'server' in self.kwargs:
                         self.sender.bind("ipc:///tmp/{}.plots".format(self.kwargs['server']))
                     else:
                         self.sender.bind("ipc:///tmp/zmq.plots")
-                    time.sleep(3)
+                    time.sleep(2)
                     t = Thread(target=self.event_monitor, args=(monitor,))
                     t.start()
                     while True:
-                        self.dataOut = self.receiver.recv_pyobj()
+                        dataOut = self.receiver.recv_pyobj()
-                        # print '[Receiving] {} - {}'.format(self.dataOut.type,
+                        dt = datetime.datetime.fromtimestamp(dataOut.utctime).date()
-                        #                                    self.dataOut.datatime.ctime())
+                        sended = False
+                        if dt not in self.dates:
-                        self.update()
+                            if self.data:
+                                self.data.ended = True
+                                self.send(self.data)
+                                sended = True
+                            self.data.setup()
+                            self.dates.append(dt)
-                        if self.dataOut.firstdata is True:
+                        self.data.update(dataOut)
-                            self.data['STARTED'] = True
-                        if self.dataOut.finished is True:
+                        if dataOut.finished is True:
-                            self.send(self.data)
                             self.connections -= 1
-                            if self.connections == 0 and self.started:
+                            if self.connections == 0 and dt in self.dates:
-                                self.ended = True
+                                self.data.ended = True
-                                self.data['ENDED'] = True
                                 self.send(self.data)
-                                self.setup()
+                                self.data.setup()
-                                self.started = False
                         else:
                             if self.realtime:
                                 self.send(self.data)
-                                self.sender_web.send_string(json.dumps(self.data_web))
+                                # self.sender_web.send_string(self.data.jsonify())
                             else:
+                                if not sended:
                                     self.sendData(self.send, self.data)
-                            self.started = True
-                        self.data['STARTED'] = False
                     return
                 def sendToWeb(self):
                     if not self.isWebConfig:
                         context = zmq.Context()
                         sender_web_config = context.socket(zmq.PUB)
                         if 'tcp://' in self.plot_address:
                             dum, address, port = self.plot_address.split(':')
                             conf_address = '{}:{}:{}'.format(dum, address, int(port)+1)
                         else:
                             conf_address = self.plot_address + '.config'
                         sender_web_config.bind(conf_address)
                         time.sleep(1)
                         for kwargs in self.operationKwargs.values():
                             if 'plot' in kwargs:
-                                print '[Sending] Config data to web for {}'.format(kwargs['code'].upper())
+                                log.success('[Sending] Config data to web for {}'.format(kwargs['code'].upper()))
                                 sender_web_config.send_string(json.dumps(kwargs))
                         self.isWebConfig = True

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