schain Commit - r1476:d08bdce68e00 · Jicamarca Repository

update fix axes, test de prueba de canales

jespinoza -

r1476:d08bdce68e00

parent child

Context file:

r1476:d08bdce68e00

schainpy/scripts/TEST_NOISE.py created 644 +362 0

@@ -0,0 +1,362
	1	#!python
	2	'''
	3	'''
	4
	5	import os, sys
	6	import datetime
	7	import time
	8
	9	#path = os.path.dirname(os.getcwd())
	10	#path = os.path.dirname(path)
	11	#sys.path.insert(0, path)
	12
	13	from schainpy.controller import Project
	14
	15	desc = "USRP_test"
	16	filename = "USRP_processing.xml"
	17	controllerObj = Project()
	18	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	19
	20	############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
	21
	22	#######################################################################
	23	######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
	24	#######################################################################
	25	#path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman'
	26	#path = '/DATA_RM/TEST_INTEGRACION'
	27	#path = '/DATA_RM/PRUEBA_USRP_RP'
	28	#path = '/DATA_RM/PRUEBA_USRP_RP'
	29
	30	path = '/DATA_RM/TEST_2M'
	31	path = '/DATA_RM/TEST_2M_UD'
	32	path = '/DATA_RM/2MHZ17022022'
	33	path = '/DATA_RM/10MHZTEST/'
	34	path = '/DATA_RM/10MHZDRONE/'
	35
	36
	37	path= '/home/soporte/TEST_500mVPP'
	38	path= '/home/soporte/TEST_1VPP+500mVDC'
	39	path = '/home/soporte/TEST_500mVPP+500mVDC'
	40	path = '/home/soporte/TEST_1.5VPP'
	41	path = '/home/soporte/TEST_2VPP'
	42	path= '/home/soporte/TEST_1VPP'
	43	path = '/home/soporte/Documents/HUANCAYO/TEST_HYO_PM@2022-05-14T11-28-19/rawdata'
	44
	45	#HYO_PM@2022-05-28T00-00-17
	46	path = '/DATA_RM/DATA/HYO_PM@2022-05-28T00-00-17/rawdata'
	47
	48	#figpath = '/home/soporte/Pictures/TEST_RP_0001'
	49	#figpath = '/home/soporte/Pictures/TEST_RP_6000'
	50	figpath = '/home/soporte/Pictures/USRP_TEST_2M'
	51	figpath = '/home/soporte/Pictures/USRP_TEST_2M_UD'
	52	figpath = '/home/soporte/Pictures/10MHZDRONE'
	53	figpath = '/home/soporte/Pictures/500mVPP'
	54	figpath = '/home/soporte/Pictures/1VPP+500mVDC'
	55	figpath = '/home/soporte/Pictures/TEST_500mVPP+500mVDC'
	56	figpath = '/home/soporte/Pictures/TEST_1.5VPP'
	57	figpath = '/home/soporte/Pictures/TEST_2VPP'
	58	figpath = '/home/soporte/Pictures/TEST_1VPP'
	59
	60
	61
	62
	63	#remotefolder = "/home/wmaster/graficos"
	64	#######################################################################
	65	################# RANGO DE PLOTEO######################################
	66	#######################################################################
	67	dBmin = '-60'#'-20'
	68	dBmax = '-5'#'-85'
	69	xmin = '0'
	70	xmax ='24'
	71	ymin = '0'
	72	ymax = '10'
	73	#######################################################################
	74	########################FECHA##########################################
	75	#######################################################################
	76	str = datetime.date.today()
	77	today = str.strftime("%Y/%m/%d")
	78	str2 = str - datetime.timedelta(days=1)
	79	yesterday = str2.strftime("%Y/%m/%d")
	80	#######################################################################
	81	######################## UNIDAD DE LECTURA#############################
	82	#######################################################################
	83	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	84	path=path,
	85	startDate="2022/05/28",#today,
	86	endDate="2022/05/28",#today,
	87	startTime='00:00:00',# inicio libre
	88	#startTime='00:00:00',
	89	endTime='23:59:59',
	90	delay=0,
	91	#set=0,
	92	online=0,
	93	walk=1,
	94	ippKm = 60)
	95
	96	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	97	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	98	#######################################################################
	99	################ OPERACIONES DOMINIO DEL TIEMPO########################
	100	#######################################################################
	101
	102	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	103
	104	op3 = procUnitConfObjA.addOperation(name='ProfileSelector', optype='other')
	105	op3.addParameter(name='profileRangeList', value='1,123')
	106
	107
	108	code=[[1]]
	109
	110	opObj11 = procUnitConfObjA.addOperation(name='Decoder', optype='other')
	111	opObj11.addParameter(name='code', value=code)
	112	opObj11.addParameter(name='nCode', value='1', format='int')
	113	opObj11.addParameter(name='nBaud', value='1', format='int')
	114
	115
	116	'''
	117	op3 = procUnitConfObjA.addOperation(name='ProfileSelector', optype='other')
	118	op3.addParameter(name='profileRangeList', value='122,249')
	119	code8=[[1,1,1,0,1,1,0,1],[1,1,1,0,0,0,1,0]]
	120
	121	opObj11 = procUnitConfObjA.addOperation(name='Decoder', optype='other')
	122	opObj11.addParameter(name='code', value=code8)
	123	opObj11.addParameter(name='nCode', value='2', format='int')
	124	opObj11.addParameter(name='nBaud', value='8', format='int')
	125	'''
	126	op = procUnitConfObjA.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
	127	op.addParameter(name='n', value=2, format='int')
	128
	129
	130	'''
	131
	132	# OJO SCOPE
	133	opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	134	opObj10.addParameter(name='id', value='10', format='int')
	135	opObj10.addParameter(name='xmin', value='0', format='int')
	136	opObj10.addParameter(name='xmax', value='60', format='int')
	137	opObj10.addParameter(name='type', value='iq')
	138	#opObj10.addParameter(name='ymin', value='-0.20000', format='int')
	139	#opObj10.addParameter(name='ymax', value='0.20000', format='int')
	140	opObj10.addParameter(name='save', value=figpath, format='str')
	141	opObj10.addParameter(name='save_period', value=1, format='int')
	142	'''
	143	'''
	144	opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
	145	opObj11.addParameter(name='minIndex', value='1', format='int')
	146	# opObj11.addParameter(name='maxIndex', value='10000', format='int')
	147	opObj11.addParameter(name='maxIndex', value='200', format='int')
	148	'''
	149	#
	150	# codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\
	151	# '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1'
	152
	153	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	154	#opObj11.addParameter(name='frequency', value='49920000')
	155
	156	'''
	157	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	158	opObj11.addParameter(name='n', value='625', format='int')#10
	159	opObj11.addParameter(name='removeDC', value=1, format='int')
	160	'''
	161
	162	# Ploteo TEST
	163	'''
	164	opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
	165	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	166	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	167	#opObj11.addParameter(name='xmax', value=8)
	168	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
	169	'''
	170	# OJO SCOPE
	171	#opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	172	#opObj10.addParameter(name='id', value='10', format='int')
	173	##opObj10.addParameter(name='xmin', value='0', format='int')
	174	##opObj10.addParameter(name='xmax', value='50', format='int')
	175	#opObj10.addParameter(name='type', value='iq')
	176	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	177	##opObj10.addParameter(name='ymax', value='8500', format='int')
	178	#opObj11.addParameter(name='save', value=figpath, format='str')
	179	#opObj11.addParameter(name='save_period', value=10, format='int')
	180
	181	#opObj10 = procUnitConfObjA.addOperation(name='setH0')
	182	#opObj10.addParameter(name='h0', value='-5000', format='float')
	183
	184	#opObj11 = procUnitConfObjA.addOperation(name='filterByHeights')
	185	#opObj11.addParameter(name='window', value='1', format='int')
	186
	187	#codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1'
	188	#opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
	189	#opObj11.addParameter(name='code', value=codigo, format='floatlist')
	190	#opObj11.addParameter(name='nCode', value='1', format='int')
	191	#opObj11.addParameter(name='nBaud', value='28', format='int')
	192
	193	#opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	194	#opObj11.addParameter(name='n', value='100', format='int')
	195
	196	#######################################################################
	197	########## OPERACIONES ParametersProc########################
	198	#######################################################################
	199	###procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	200	'''
	201
	202	opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
	203	opObj11.addParameter(name='path_ped', value=path_ped)
	204	opObj11.addParameter(name='path_adq', value=path_adq)
	205	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	206	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	207	opObj11.addParameter(name='blocksPerfile', value='100', format='int')
	208	opObj11.addParameter(name='f_a_p', value='25', format='int')
	209	opObj11.addParameter(name='online', value='0', format='int')
	210
	211	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	212	opObj11.addParameter(name='n', value='40', format='int')
	213
	214	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	215	opObj11.addParameter(name='save', value=figpath)
	216	opObj11.addParameter(name='save_period', value=1)
	217
	218	8
	219	'''
	220
	221
	222	'''
	223	opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	224	opObj11.addParameter(name='n', value='250', format='int')
	225	'''
	226	#######################################################################
	227	########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
	228	#######################################################################
	229	'''
	230	procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	231	procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int')
	232	procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int')
	233	'''
	234
	235	procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	236	procUnitConfObjB.addParameter(name='nFFTPoints', value='61', format='int')
	237	procUnitConfObjB.addParameter(name='nProfiles', value='61', format='int')
	238
	239	'''
	240	procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
	241	#procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int')
	242	#procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int')
	243	opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
	244	#opObj11.addParameter(name='timeInterval', value='4', format='int')
	245	opObj11.addParameter(name='n', value='100', format='int')
	246
	247	#procUnitConfObjB.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList')
	248
	249	#opObj13 = procUnitConfObjB.addOperation(name='removeDC')
	250	#opObj13.addParameter(name='mode', value='2', format='int')
	251
	252	#opObj11 = procUnitConfObjB.addOperation(name='IncohInt', optype='other')
	253	#opObj11.addParameter(name='n', value='8', format='float')
	254	#######################################################################
	255	########## PLOTEO DOMINIO DE LA FRECUENCIA#############################
	256	#######################################################################
	257	#----
	258	'''
	259	'''
	260	opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
	261	opObj11.addParameter(name='id', value='10', format='int')
	262	opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
	263	#opObj11.addParameter(name='xmin', value=-100000, format='float')
	264	#opObj11.addParameter(name='xmax', value=100000, format='float')
	265	opObj11.addParameter(name='oneFigure', value=False,format='bool')
	266	#opObj11.addParameter(name='zmin', value=-10, format='int')
	267	#opObj11.addParameter(name='zmax', value=40, format='int')
	268	opObj11.addParameter(name='ymin', value=10, format='int')
	269	opObj11.addParameter(name='ymax', value=55, format='int')
	270	opObj11.addParameter(name='grid', value=True, format
	271	[Reading] 2022-05-23 12:27:32.732775: 21333 samples <> 0.010667 sec
	272	='bool')
	273	#opObj11.addParameter(name='showprofile', value='1', format='int')
	274	opObj11.addParameter(name='save', value=figpath, format='str')
	275	#opObj11.addParameter(name='save_period', value=10, format='int')
	276	'''
	277	'''
	278	opObj11 = procUnitConfObjC.addOperation(name='RTIHeisPlot')
	279	opObj11.addParameter(name='id', value='10', format='int')
	280	opObj11.addParameter(name='wintitle', value='RTI_Alturas', format='str')
	281	opObj11.addParameter(name='xmin', value=11.0, format='float')
	282	opObj11.addParameter(name='xmax', value=18.0, format='float')
	283	opObj11.addParameter(name='zmin', value=10, format='int')
	284	opObj11.addParameter(name='zmax', value=30, format='int')
	285	opObj11.addParameter(name='ymin', value=5, format='int')
	286	opObj11.addParameter(name='ymax', value=28, format='int')
	287	opObj11.addParameter(name='showprofile', value='1', format='int')
	288	opObj11.addParameter(name='save', value=figpath, format='str')
	289	opObj11.addParameter(name='save_period', value=10, format='int')
	290	'''
	291
	292	#SpectraPlot
	293
	294	opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
	295	opObj11.addParameter(name='id', value='1', format='int')
	296	opObj11.addParameter(name='wintitle', value='Spectra', format='str')
	297	#opObj11.addParameter(name='xmin', value=-0.01, format='float')
	298	#opObj11.addParameter(name='xmax', value=0.01, format='float')
	299	opObj11.addParameter(name='zmin', value=dBmin, format='int')
	300	opObj11.addParameter(name='zmax', value=dBmax, format='int')
	301	opObj11.addParameter(name='ymin', value=ymin, format='int')
	302	opObj11.addParameter(name='ymax', value=ymax, format='int')
	303	opObj11.addParameter(name='showprofile', value='1', format='int')
	304	opObj11.addParameter(name='save', value=figpath, format='str')
	305	opObj11.addParameter(name='save_period', value=10, format='int')
	306
	307
	308	#RTIPLOT
	309	'''
	310	opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external')
	311	opObj11.addParameter(name='id', value='2', format='int')
	312	opObj11.addParameter(name='wintitle', value='RTIPlot', format='str')
	313	opObj11.addParameter(name='zmin', value=dBmin, format='int')
	314	opObj11.addParameter(name='zmax', value=dBmax, format='int')
	315	#opObj11.addParameter(name='ymin', value=ymin, format='int')
	316	#opObj11.addParameter(name='ymax', value=ymax, format='int')
	317	#opObj11.addParameter(name='xmin', value=15, format='int')
	318	#opObj11.addParameter(name='xmax', value=16, format='int')
	319	opObj11.addParameter(name='zmin', value=dBmin, format='int')
	320	opObj11.addParameter(name='zmax', value=dBmax, format='int')
	321
	322	opObj11.addParameter(name='showprofile', value='1', format='int')
	323	opObj11.addParameter(name='save', value=figpath, format='str')
	324	opObj11.addParameter(name='save_period', value=10, format='int')
	325	'''
	326	'''
	327	# opObj11 = procUnitConfObjB.addOperation(name='CrossSpectraPlot', optype='other')
	328	# opObj11.addParameter(name='id', value='3', format='int')
	329	# opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
	330	# opObj11.addParameter(name='ymin', value=ymin, format='int')
	331	# opObj11.addParameter(name='ymax', value=ymax, format='int')
	332	# opObj11.addParameter(name='phase_cmap', value='jet', format='str')
	333	# opObj11.addParameter(name='zmin', value=dBmin, format='int')
	334	# opObj11.addParameter(name='zmax', value=dBmax, format='int')
	335	# opObj11.addParameter(name='figpath', value=figures_path, format='str')
	336	# opObj11.addParameter(name='save', value=0, format='bool')
	337	# opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
	338	# #
	339	# opObj11 = procUnitConfObjB.addOperation(name='CoherenceMap', optype='other')
	340	# opObj11.addParameter(name='id', value='4', format='int')
	341	# opObj11.addParameter(name='wintitle', value='Coherence', format='str')
	342	# opObj11.addParameter(name='phase_cmap', value='jet', format='str')
	343	# opObj11.addParameter(name='xmin', value=xmin, format='float')
	344	# opObj11.addParameter(name='xmax', value=xmax, format='float')
	345	# opObj11.addParameter(name='figpath', value=figures_path, format='str')
	346	# opObj11.addParameter(name='save', value=0, format='bool')
	347	# opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
	348	#
	349	'''
	350	'''
	351	#######################################################################
	352	############### UNIDAD DE ESCRITURA ###################################
	353	#######################################################################
	354	#opObj11 = procUnitConfObjB.addOperation(name='SpectraWriter', optype='other')
	355	#opObj11.addParameter(name='path', value=wr_path)
	356	#opObj11.addParameter(name='blocksPerFile', value='50', format='int')
	357	print ("Escribiendo el archivo XML")
	358	print ("Leyendo el archivo XML")
	359	'''
	360
	361
	362	controllerObj.start()

schainpy/model/graphics/jroplot_base.py +3 -3

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Base class to create plot operations
             """
             import os
             import sys
             import zmq
             import time
             import numpy
             import datetime
             from collections import deque
             from functools import wraps
             from threading import Thread
             import matplotlib
             if 'BACKEND' in os.environ:
                 matplotlib.use(os.environ['BACKEND'])
             elif 'linux' in sys.platform:
                 matplotlib.use("TkAgg")
             elif 'darwin' in sys.platform:
                 matplotlib.use('MacOSX')
             else:
                 from schainpy.utils import log
                 log.warning('Using default Backend="Agg"', 'INFO')
                 matplotlib.use('Agg')
             import matplotlib.pyplot as plt
             from matplotlib.patches import Polygon
             from mpl_toolkits.axes_grid1 import make_axes_locatable
             from matplotlib.ticker import FuncFormatter, LinearLocator, MultipleLocator
             from schainpy.model.data.jrodata import PlotterData
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.utils import log
             jet_values = matplotlib.pyplot.get_cmap('jet', 100)(numpy.arange(100))[10:90]
             blu_values = matplotlib.pyplot.get_cmap(
                 'seismic_r', 20)(numpy.arange(20))[10:15]
             ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
                 'jro', numpy.vstack((blu_values, jet_values)))
             matplotlib.pyplot.register_cmap(cmap=ncmap)
             CMAPS = [plt.get_cmap(s) for s in ('jro', 'jet', 'viridis',
                                                'plasma', 'inferno', 'Greys', 'seismic', 'bwr', 'coolwarm')]
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             def figpause(interval):
                 backend = plt.rcParams['backend']
                 if backend in matplotlib.rcsetup.interactive_bk:
                     figManager = matplotlib._pylab_helpers.Gcf.get_active()
                     if figManager is not None:
                         canvas = figManager.canvas
                         if canvas.figure.stale:
                             canvas.draw()
                         try:
                             canvas.start_event_loop(interval)
                         except:
                             pass
                         return
             def popup(message):
                 '''
                 '''
                 fig = plt.figure(figsize=(12, 8), facecolor='r')
                 text = '\n'.join([s.strip() for s in message.split(':')])
                 fig.text(0.01, 0.5, text, ha='left', va='center',
                          size='20', weight='heavy', color='w')
                 fig.show()
                 figpause(1000)
             class Throttle(object):
                 '''
                 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):
                         coerce = kwargs.pop('coerce', None)
                         if coerce:
                             self.time_of_last_call = datetime.datetime.now()
                             return fn(*args, **kwargs)
                         else:
                             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
             def apply_throttle(value):
                 @Throttle(seconds=value)
                 def fnThrottled(fn):
                     fn()
                 return fnThrottled
             @MPDecorator
             class Plot(Operation):
                 """Base class for Schain plotting operations
                 This class should never be use directtly you must subclass a new operation,
                 children classes must be defined as follow:
                 ExamplePlot(Plot):
                     CODE = 'code'
                     colormap = 'jet'
                     plot_type = 'pcolor' # options are ('pcolor', 'pcolorbuffer', 'scatter', 'scatterbuffer')
                     def setup(self):
                         pass
                     def plot(self):
                         pass
                 """
                 CODE = 'Figure'
                 colormap = 'jet'
                 bgcolor = 'white'
                 buffering = True
                 __missing = 1E30
                 __attrs__ = ['show', 'save', 'ymin', 'ymax', 'zmin', 'zmax', 'title',
                              'showprofile']
                 def __init__(self):
                     Operation.__init__(self)
                     self.isConfig = False
                     self.isPlotConfig = False
                     self.save_time = 0
                     self.sender_time = 0
                     self.data = None
                     self.firsttime = True
                     self.sender_queue = deque(maxlen=10)
                     self.plots_adjust = {'left': 0.125, 'right': 0.9, 'bottom': 0.15, 'top': 0.9, 'wspace': 0.2, 'hspace': 0.2}
                 def __fmtTime(self, x, pos):
                     '''
                     '''
                     return '{}'.format(self.getDateTime(x).strftime('%H:%M'))
                 def __setup(self, **kwargs):
                     '''
                     Initialize variables
                     '''
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.localtime = kwargs.pop('localtime', True)
                     self.show = kwargs.get('show', True)
                     self.save = kwargs.get('save', False)
                     self.save_period = kwargs.get('save_period', 0)
                     self.colormap = kwargs.get('colormap', self.colormap)
                     self.colormap_coh = kwargs.get('colormap_coh', 'jet')
                     self.colormap_phase = kwargs.get('colormap_phase', 'RdBu_r')
                     self.colormaps = kwargs.get('colormaps', None)
                     self.bgcolor = kwargs.get('bgcolor', self.bgcolor)
                     self.showprofile = kwargs.get('showprofile', False)
                     self.title = kwargs.get('wintitle', self.CODE.upper())
                     self.cb_label = kwargs.get('cb_label', None)
                     self.cb_labels = kwargs.get('cb_labels', None)
                     self.labels = kwargs.get('labels', None)
                     self.xaxis = kwargs.get('xaxis', 'frequency')
                     self.zmin = kwargs.get('zmin', None)
                     self.zmax = kwargs.get('zmax', None)
                     self.zlimits = kwargs.get('zlimits', None)
                     self.xmin = kwargs.get('xmin', None)
                     self.xmax = kwargs.get('xmax', None)
                     self.xrange = kwargs.get('xrange', 12)
                     self.xscale = kwargs.get('xscale', None)
                     self.ymin = kwargs.get('ymin', None)
                     self.ymax = kwargs.get('ymax', None)
                     self.yscale = kwargs.get('yscale', None)
                     self.xlabel = kwargs.get('xlabel', None)
                     self.attr_time = kwargs.get('attr_time', 'utctime')
                     self.attr_data = kwargs.get('attr_data', 'data_param')
                     self.decimation = kwargs.get('decimation', None)
                     self.oneFigure = kwargs.get('oneFigure', True)
                     self.width = kwargs.get('width', None)
                     self.height = kwargs.get('height', None)
                     self.colorbar = kwargs.get('colorbar', True)
                     self.factors = kwargs.get('factors', [1, 1, 1, 1, 1, 1, 1, 1])
                     self.channels = kwargs.get('channels', None)
                     self.titles = kwargs.get('titles', [])
                     self.polar = False
                     self.type = kwargs.get('type', 'iq')
                     self.grid = kwargs.get('grid', False)
                     self.pause = kwargs.get('pause', False)
                     self.save_code = kwargs.get('save_code', self.CODE)
                     self.throttle = kwargs.get('throttle', 0)
                     self.exp_code = kwargs.get('exp_code', None)
                     self.server = kwargs.get('server', False)
                     self.sender_period = kwargs.get('sender_period', 60)
                     self.tag = kwargs.get('tag', '')
                     self.height_index = kwargs.get('height_index', None)
                     self.__throttle_plot = apply_throttle(self.throttle)
                     code = self.attr_data if self.attr_data else self.CODE
                     self.data = PlotterData(self.CODE, self.exp_code, self.localtime)
                     self.ang_min = kwargs.get('ang_min', None)
                     self.ang_max = kwargs.get('ang_max', None)
                     self.mode = kwargs.get('mode', None)
                     if self.server:
                         if not self.server.startswith('tcp://'):
                             self.server = 'tcp://{}'.format(self.server)
                         log.success(
                             'Sending to server: {}'.format(self.server),
                             self.name
                         )
                     if isinstance(self.attr_data, str):
                         self.attr_data = [self.attr_data]
                 def __setup_plot(self):
                     '''
                     Common setup for all figures, here figures and axes are created
                     '''
                     self.setup()
                     self.time_label = 'LT' if self.localtime else 'UTC'
                     if self.width is None:
                         self.width = 8
                     self.figures = []
                     self.axes = []
                     self.cb_axes = []
                     self.pf_axes = []
                     self.cmaps = []
                     size = '15%' if self.ncols == 1 else '30%'
                     pad = '4%' if self.ncols == 1 else '8%'
                     if self.oneFigure:
                         if self.height is None:
                             self.height = 1.4 * self.nrows + 1
                         fig = plt.figure(figsize=(self.width, self.height),
                                          edgecolor='k',
                                          facecolor='w')
                         self.figures.append(fig)
                         for n in range(self.nplots):
                             ax = fig.add_subplot(self.nrows, self.ncols,
                                                  n + 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     else:
                         if self.height is None:
                             self.height = 3
                         for n in range(self.nplots):
                             fig = plt.figure(figsize=(self.width, self.height),
                                              edgecolor='k',
                                              facecolor='w')
                             ax = fig.add_subplot(1, 1, 1, polar=self.polar)
                             ax.tick_params(labelsize=8)
                             ax.firsttime = True
                             ax.index = 0
                             ax.press = None
                             self.figures.append(fig)
                             self.axes.append(ax)
                             if self.showprofile:
                                 cax = self.__add_axes(ax, size=size, pad=pad)
                                 cax.tick_params(labelsize=8)
                                 self.pf_axes.append(cax)
                     for n in range(self.nrows):
                         if self.colormaps is not None:
                             cmap = plt.get_cmap(self.colormaps[n])
                         else:
                             cmap = plt.get_cmap(self.colormap)
                         cmap.set_bad(self.bgcolor, 1.)
                         self.cmaps.append(cmap)
                 def __add_axes(self, ax, size='30%', pad='8%'):
                     '''
                     Add new axes to the given figure
                     '''
                     divider = make_axes_locatable(ax)
                     nax = divider.new_horizontal(size=size, pad=pad)
                     ax.figure.add_axes(nax)
                     return nax
                 def fill_gaps(self, x_buffer, y_buffer, z_buffer):
                     '''
                     Create a masked array for missing data
                     '''
                     if x_buffer.shape[0] < 2:
                         return x_buffer, y_buffer, z_buffer
                     deltas = x_buffer[1:] - x_buffer[0:-1]
                     x_median = numpy.median(deltas)
                     index = numpy.where(deltas > 5 * x_median)
                     if len(index[0]) != 0:
                         z_buffer[::, index[0], ::] = self.__missing
                         z_buffer = numpy.ma.masked_inside(z_buffer,
 .99 * self.__missing,
 .01 * self.__missing)
                     return x_buffer, y_buffer, z_buffer
                 def decimate(self):
                     # dx = int(len(self.x)/self.__MAXNUMX) + 1
                     dy = int(len(self.y) / self.decimation) + 1
                     # x = self.x[::dx]
                     x = self.x
                     y = self.y[::dy]
                     z = self.z[::, ::, ::dy]
                     return x, y, z
                 def format(self):
                     '''
                     Set min and max values, labels, ticks and titles
                     '''
                     for n, ax in enumerate(self.axes):
                         if ax.firsttime:
                             if self.xaxis != 'time':
                                 xmin = self.xmin
                                 xmax = self.xmax
                             else:
                                 xmin = self.tmin
                                 xmax = self.tmin + self.xrange*60*60
                                 ax.xaxis.set_major_formatter(FuncFormatter(self.__fmtTime))
                                 ax.xaxis.set_major_locator(LinearLocator(9))
                             ymin = self.ymin if self.ymin is not None else numpy.nanmin(self.y[numpy.isfinite(self.y)])
                             ymax = self.ymax if self.ymax is not None else numpy.nanmax(self.y[numpy.isfinite(self.y)])
                             ax.set_facecolor(self.bgcolor)
                             if self.xscale:
                                 ax.xaxis.set_major_formatter(FuncFormatter(
                                     lambda x, pos: '{0:g}'.format(x*self.xscale)))
                             if self.yscale:
                                 ax.yaxis.set_major_formatter(FuncFormatter(
                                     lambda x, pos: '{0:g}'.format(x*self.yscale)))
                             if self.xlabel is not None:
                                 ax.set_xlabel(self.xlabel)
                             if self.ylabel is not None:
                                 ax.set_ylabel(self.ylabel)
                             if self.showprofile:
                                 self.pf_axes[n].set_ylim(ymin, ymax)
                                 self.pf_axes[n].set_xlim(self.zmin, self.zmax)
                                 self.pf_axes[n].set_xlabel('dB')
                                 self.pf_axes[n].grid(b=True, axis='x')
                                 [tick.set_visible(False)
                                  for tick in self.pf_axes[n].get_yticklabels()]
                             if self.colorbar:
                                 ax.cbar = plt.colorbar(
-                                    ax.plt, ax=ax, fraction=0.05, pad=0.02, aspect=10)
+                                    ax.plt, ax=ax, fraction=0.05, pad=0.06, aspect=10)
                                 ax.cbar.ax.tick_params(labelsize=8)
                                 ax.cbar.ax.press = None
                                 if self.cb_label:
                                     ax.cbar.set_label(self.cb_label, size=8)
                                 elif self.cb_labels:
                                     ax.cbar.set_label(self.cb_labels[n], size=8)
                             else:
                                 ax.cbar = None
                             ax.set_xlim(xmin, xmax)
                             ax.set_ylim(ymin, ymax)
                             ax.firsttime = False
                             if self.grid:
                                 ax.grid(True)
                         if not self.polar:
                             ax.set_title('{} {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y-%m-%d %H:%M:%S'),
                                 self.time_label),
                                 size=8)
                         else:
                             #ax.set_title('{}'.format(self.titles[n]), size=8)
                             ax.set_title('{} {} {}'.format(
                                 self.titles[n],
                                 self.getDateTime(self.data.max_time).strftime(
                                     '%Y-%m-%d %H:%M:%S'),
                                 self.time_label),
                                 size=8)
                             ax.set_ylim(0, self.ymax)
                             #ax.set_yticks(numpy.arange(0, self.ymax, 20))
-                            ax.yaxis.labelpad = 20
+                            ax.yaxis.labelpad = 28
                     if self.firsttime:
                         for n, fig in enumerate(self.figures):
                             fig.subplots_adjust(**self.plots_adjust)
                         self.firsttime = False
                 def clear_figures(self):
                     '''
                     Reset axes for redraw plots
                     '''
                     for ax in self.axes+self.pf_axes+self.cb_axes:
                         ax.clear()
                         ax.firsttime = True
                         if hasattr(ax, 'cbar') and ax.cbar:
                             ax.cbar.remove()
                 def __plot(self):
                     '''
                     Main function to plot, format and save figures
                     '''
                     self.plot()
                     self.format()
                     for n, fig in enumerate(self.figures):
                         if self.nrows == 0 or self.nplots == 0:
                             log.warning('No data', self.name)
                             fig.text(0.5, 0.5, 'No Data', fontsize='large', ha='center')
                             fig.canvas.manager.set_window_title(self.CODE)
                             continue
                         fig.canvas.manager.set_window_title('{} - {}'.format(self.title,
                                                                              self.getDateTime(self.data.max_time).strftime('%Y/%m/%d')))
                         fig.canvas.draw()
                         if self.show:
                             fig.show()
                             figpause(0.01)
                         if self.save:
                             self.save_figure(n)
                     if self.server:
                         self.send_to_server()
                 def __update(self, dataOut, timestamp):
                     '''
                     '''
                     metadata = {
                         'yrange': dataOut.heightList,
                         'interval': dataOut.timeInterval,
                         'channels': dataOut.channelList
                     }
                     data, meta = self.update(dataOut)
                     metadata.update(meta)
                     self.data.update(data, timestamp, metadata)
                 def save_figure(self, n):
                     '''
                     '''
                     if self.oneFigure:
                         if (self.data.max_time - self.save_time) <= self.save_period:
                             return
                     self.save_time = self.data.max_time
                     fig = self.figures[n]
                     if self.throttle == 0:
                         if self.oneFigure:
                             figname = os.path.join(
                                 self.save,
                                 self.save_code,
                                 '{}_{}.png'.format(
                                     self.save_code,
                                     self.getDateTime(self.data.max_time).strftime(
                                         '%Y%m%d_%H%M%S'
                                         ),
                                     )
                                 )
                         else:
                             figname = os.path.join(
                                 self.save,
                                 self.save_code,
                                 '{}_ch{}_{}.png'.format(
                                     self.save_code,n,
                                     self.getDateTime(self.data.max_time).strftime(
                                         '%Y%m%d_%H%M%S'
                                         ),
                                     )
                                 )
                         log.log('Saving figure: {}'.format(figname), self.name)
                         if not os.path.isdir(os.path.dirname(figname)):
                             os.makedirs(os.path.dirname(figname))
                         fig.savefig(figname)
                     figname = os.path.join(
                         self.save,
                         '{}_{}.png'.format(
                             self.save_code,
                             self.getDateTime(self.data.min_time).strftime(
                                 '%Y%m%d'
                                 ),
                             )
                         )
                     log.log('Saving figure: {}'.format(figname), self.name)
                     if not os.path.isdir(os.path.dirname(figname)):
                         os.makedirs(os.path.dirname(figname))
                     fig.savefig(figname)
                 def send_to_server(self):
                     '''
                     '''
                     if self.exp_code == None:
                         log.warning('Missing `exp_code` skipping sending to server...')
                     last_time = self.data.max_time
                     interval = last_time - self.sender_time
                     if interval < self.sender_period:
                         return
                     self.sender_time = last_time
                     attrs = ['titles', 'zmin', 'zmax', 'tag', 'ymin', 'ymax']
                     for attr in attrs:
                         value = getattr(self, attr)
                         if value:
                             if isinstance(value, (numpy.float32, numpy.float64)):
                                 value = round(float(value), 2)
                             self.data.meta[attr] = value
                     if self.colormap == 'jet':
                         self.data.meta['colormap'] = 'Jet'
                     elif 'RdBu' in self.colormap:
                         self.data.meta['colormap'] = 'RdBu'
                     else:
                         self.data.meta['colormap'] = 'Viridis'
                     self.data.meta['interval'] = int(interval)
                     self.sender_queue.append(last_time)
                     while True:
                         try:
                             tm = self.sender_queue.popleft()
                         except IndexError:
                             break
                         msg = self.data.jsonify(tm, self.save_code, self.plot_type)
                         self.socket.send_string(msg)
                         socks = dict(self.poll.poll(2000))
                         if socks.get(self.socket) == zmq.POLLIN:
                             reply = self.socket.recv_string()
                             if reply == 'ok':
                                 log.log("Response from server ok", self.name)
                                 time.sleep(0.1)
                                 continue
                             else:
                                 log.warning(
                                     "Malformed reply from server: {}".format(reply), self.name)
                         else:
                             log.warning(
                                 "No response from server, retrying...", self.name)
                         self.sender_queue.appendleft(tm)
                         self.socket.setsockopt(zmq.LINGER, 0)
                         self.socket.close()
                         self.poll.unregister(self.socket)
                         self.socket = self.context.socket(zmq.REQ)
                         self.socket.connect(self.server)
                         self.poll.register(self.socket, zmq.POLLIN)
                         break
                 def setup(self):
                     '''
                     This method should be implemented in the child class, the following
                     attributes should be set:
                     self.nrows: number of rows
                     self.ncols: number of cols
                     self.nplots: number of plots (channels or pairs)
                     self.ylabel: label for Y axes
                     self.titles: list of axes title
                     '''
                     raise NotImplementedError
                 def plot(self):
                     '''
                     Must be defined in the child class, the actual plotting method
                     '''
                     raise NotImplementedError
                 def update(self, dataOut):
                     '''
                     Must be defined in the child class, update self.data with new data
                     '''
                     data = {
                         self.CODE: getattr(dataOut, 'data_{}'.format(self.CODE))
                     }
                     meta = {}
                     return data, meta
                 def run(self, dataOut, **kwargs):
                     '''
                     Main plotting routine
                     '''
                     if self.isConfig is False:
                         self.__setup(**kwargs)
                         if self.localtime:
                             self.getDateTime = datetime.datetime.fromtimestamp
                         else:
                             self.getDateTime = datetime.datetime.utcfromtimestamp
                         self.data.setup()
                         self.isConfig = True
                         if self.server:
                             self.context = zmq.Context()
                             self.socket = self.context.socket(zmq.REQ)
                             self.socket.connect(self.server)
                             self.poll = zmq.Poller()
                             self.poll.register(self.socket, zmq.POLLIN)
                     tm = getattr(dataOut, self.attr_time)
                     if self.data and 'time' in self.xaxis and (tm - self.tmin) >= self.xrange*60*60:
                         self.save_time = tm
                         self.__plot()
                         self.tmin += self.xrange*60*60
                         self.data.setup()
                         self.clear_figures()
                     self.__update(dataOut, tm)
                     if self.isPlotConfig is False:
                         self.__setup_plot()
                         self.isPlotConfig = True
                         if self.xaxis == 'time':
                             dt = self.getDateTime(tm)
                             if self.xmin is None:
                                 self.tmin = tm
                                 self.xmin = dt.hour
                             minutes = (self.xmin-int(self.xmin)) * 60
                             seconds = (minutes - int(minutes)) * 60
                             self.tmin = (dt.replace(hour=int(self.xmin), minute=int(minutes), second=int(seconds)) -
                                     datetime.datetime(1970, 1, 1)).total_seconds()
                             if self.localtime:
                                 self.tmin += time.timezone
                             if self.xmin is not None and self.xmax is not None:
                                 self.xrange = self.xmax - self.xmin
                     if self.throttle == 0:
                         self.__plot()
                     else:
                         self.__throttle_plot(self.__plot)#, coerce=coerce)
                 def close(self):
                     if self.data and not self.data.flagNoData:
                         self.save_time = 0
                         self.__plot()
                     if self.data and not self.data.flagNoData and self.pause:
                         figpause(10)

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

             import os
             import datetime
             import numpy
             from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
             from schainpy.model.graphics.jroplot_base import Plot, plt
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             # libreria wradlib
             #import wradlib as wrl
             EARTH_RADIUS = 6.3710e3
             def ll2xy(lat1, lon1, lat2, lon2):
                 p = 0.017453292519943295
                 a = 0.5 - numpy.cos((lat2 - lat1) * p)/2 + numpy.cos(lat1 * p) * \
                     numpy.cos(lat2 * p) * (1 - numpy.cos((lon2 - lon1) * p)) / 2
                 r = 12742 * numpy.arcsin(numpy.sqrt(a))
                 theta = numpy.arctan2(numpy.sin((lon2-lon1)*p)*numpy.cos(lat2*p), numpy.cos(lat1*p)
                                       * numpy.sin(lat2*p)-numpy.sin(lat1*p)*numpy.cos(lat2*p)*numpy.cos((lon2-lon1)*p))
                 theta = -theta + numpy.pi/2
                 return r*numpy.cos(theta), r*numpy.sin(theta)
             def km2deg(km):
                 '''
                 Convert distance in km to degrees
                 '''
                 return numpy.rad2deg(km/EARTH_RADIUS)
             class SpectralMomentsPlot(SpectraPlot):
                 '''
                 Plot for Spectral Moments
                 '''
                 CODE = 'spc_moments'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DobleGaussianPlot(SpectraPlot):
                 '''
                 Plot for Double Gaussian Plot
                 '''
                 CODE = 'gaussian_fit'
                 # colormap = 'jet'
                 # plot_type = 'pcolor'
             class DoubleGaussianSpectraCutPlot(SpectraCutPlot):
                 '''
                 Plot SpectraCut with Double Gaussian Fit
                 '''
                 CODE = 'cut_gaussian_fit'
             class SnrPlot(RTIPlot):
                 '''
                 Plot for SNR Data
                 '''
                 CODE = 'snr'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'snr': 10*numpy.log10(dataOut.data_snr)
                     }
                     return data, {}
             class DopplerPlot(RTIPlot):
                 '''
                 Plot for DOPPLER Data (1st moment)
                 '''
                 CODE = 'dop'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'dop': 10*numpy.log10(dataOut.data_dop)
                     }
                     return data, {}
             class PowerPlot(RTIPlot):
                 '''
                 Plot for Power Data (0 moment)
                 '''
                 CODE = 'pow'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'pow': 10*numpy.log10(dataOut.data_pow/dataOut.normFactor)
                     }
                     return data, {}
             class SpectralWidthPlot(RTIPlot):
                 '''
                 Plot for Spectral Width Data (2nd moment)
                 '''
                 CODE = 'width'
                 colormap = 'jet'
                 def update(self, dataOut):
                     data = {
                         'width': dataOut.data_width
                     }
                     return data, {}
             class SkyMapPlot(Plot):
                 '''
                 Plot for meteors detection data
                 '''
                 CODE = 'param'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 7.2
                     self.height = 7.2
                     self.nplots = 1
                     self.xlabel = 'Zonal Zenith Angle (deg)'
                     self.ylabel = 'Meridional Zenith Angle (deg)'
                     self.polar = True
                     self.ymin = -180
                     self.ymax = 180
                     self.colorbar = False
                 def plot(self):
                     arrayParameters = numpy.concatenate(self.data['param'])
                     error = arrayParameters[:, -1]
                     indValid = numpy.where(error == 0)[0]
                     finalMeteor = arrayParameters[indValid, :]
                     finalAzimuth = finalMeteor[:, 3]
                     finalZenith = finalMeteor[:, 4]
                     x = finalAzimuth * numpy.pi / 180
                     y = finalZenith
                     ax = self.axes[0]
                     if ax.firsttime:
                         ax.plot = ax.plot(x, y, 'bo', markersize=5)[0]
                     else:
                         ax.plot.set_data(x, y)
                     dt1 = self.getDateTime(self.data.min_time).strftime('%y/%m/%d %H:%M:%S')
                     dt2 = self.getDateTime(self.data.max_time).strftime('%y/%m/%d %H:%M:%S')
                     title = 'Meteor Detection Sky Map\n %s - %s \n Number of events: %5.0f\n' % (dt1,
                                                                                                  dt2,
                                                                                                  len(x))
                     self.titles[0] = title
             class GenericRTIPlot(Plot):
                 '''
                 Plot for data_xxxx object
                 '''
                 CODE = 'param'
                 colormap = 'viridis'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = self.data.shape('param')[0]
                     self.nplots = self.nrows
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95, 'top': 0.95})
                     if not self.xlabel:
                         self.xlabel = 'Time'
                     self.ylabel = 'Range [km]'
                     if not self.titles:
                         self.titles = ['Param {}'.format(x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {
                         'param' : numpy.concatenate([getattr(dataOut, attr) for attr in self.attr_data], axis=0)
                     }
                     meta = {}
                     return data, meta
                 def plot(self):
                     # self.data.normalize_heights()
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data['param']
                     self.z = 10*numpy.log10(self.z)
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class WeatherPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width   =8
                     self.height  =8
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     self.colorbar=False
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_azi   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_azi = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     #print("DIME EL SHAPE PORFAVOR",dataOut.data_360.shape)
                     data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         diff_ = angulos[i]-angulos[i-1]
                         if diff_ >1.5:
                             list1.append(i-1)
                             list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData360(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+360
                         return ang_
                     return ang_
                 def fixData360HL(self,angulos):
                     vec = numpy.where(angulos>=360)
                     angulos[vec]=angulos[vec]-360
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(list2_[i])-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(list2_[value])-1):
                                 ang_new[pos+k]  = ang_new[pos+k-1]+1
                                 ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos):
                     l1,l2 = self.get2List(angulos)
                     if len(l1)>0:
                         angulos2 = self.fixData360(list_=l1,ang_=angulos)
                         l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos2,list1_=l1,list2_=l2)
                         ang1_ = self.fixData360HL(ang1_)
                         ang2_ = self.fixData360HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def analizeDATA(self,data_azi):
                     list1 = []
                     list2 = []
                     dat   = data_azi
                     for i in reversed(range(1,len(dat))):
                         if dat[i]>dat[i-1]:
                             diff = int(dat[i])-int(dat[i-1])
                         else:
                             diff = 360+int(dat[i])-int(dat[i-1])
                         if diff > 1:
                             list1.append(i-1)
                             list2.append(diff-1)
                     return list1,list2
                 def fixDATANEW(self,data_azi,data_weather):
                     list1,list2 = self.analizeDATA(data_azi)
                     if len(list1)== 0:
                         return data_azi,data_weather
                     else:
                         resize = 0
                         for i in range(len(list2)):
                             resize=  resize + list2[i]
                         new_data_azi = numpy.resize(data_azi,resize)
                         new_data_weather= numpy.resize(date_weather,resize)
                         for i in range(len(list2)):
                             j=0
                             position=list1[i]+1
                             for j in range(list2[i]):
                                 new_data_azi[position+j]=new_data_azi[position+j-1]+1
                     return new_data_azi
                 def fixDATA(self,data_azi):
                     data=data_azi
                     for i in range(len(data)):
                         if numpy.isnan(data[i]):
                            data[i]=data[i-1]+1
                     return data
                 def replaceNAN(self,data_weather,data_azi,val):
                     data= data_azi
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     if self.ini==0:
                         #-------
                         n     = (360/res)-len(data_azi)
                         #--------------------- new -------------------------
                         data_azi_new ,data_azi_old= self.globalCheckPED(data_azi)
                         #------------------------
                         start = data_azi_new[-1] + res
                         end   = data_azi_new[0]  - res
                         #------ new
                         self.last_data_azi = end
                         if start>end:
                             end        = end + 360
                         azi_vacia = numpy.linspace(start,end,int(n))
                         azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
                         data_azi  = numpy.hstack((data_azi_new,azi_vacia))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
                         #-----------new------------
                         data_azi ,data_azi_old= self.globalCheckPED(data_azi)
                         data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         #--------------------------
                         start = data_azi[0]
                         end   = data_azi[-1]
                         self.last_data_azi= end
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
                         pos_ini = int((start-start_azi)/res)
                         len_azi = len(data_azi)
                         if (360-pos_ini)<len_azi:
                             if pos_ini+1==360:
                                 pos_ini=0
                             else:
                                 flag=1
                                 dif= 360-pos_ini
                                 comp= len_azi-dif
                         #-----------------
                         if flag==0:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
                         else:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
                             self.res_azi[0:comp]              = data_azi[dif:]
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
                             self.res_weather[0:comp,:]              = data_weather[dif:,:]
                             flag=0
                         data_azi                                    = self.res_azi
                         data_weather                                = self.res_weather
                     return data_weather,data_azi
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res          = 1
                     # STEP
                     step         = (360/(res*data['weather'].shape[0]))
                     self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
                     self.res_ele = numpy.mean(data['ele'])
                     #################    PLOTEO           ###################
                     for i,ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else 20
                         self.zmax = self.zmax if self.zmax else 80
                         if ax.firsttime:
                             plt.clf()
                             cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
                         else:
                             plt.clf()
                             cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=self.zmin, vmax=self.zmax)
                     caax = cgax.parasites[0]
                     paax = cgax.parasites[1]
                     cbar = plt.gcf().colorbar(pm, pad=0.075)
                     caax.set_xlabel('x_range [km]')
                     caax.set_ylabel('y_range [km]')
                     plt.text(1.0, 1.05, 'Azimuth '+str(thisDatetime)+"  Step   "+str(self.ini)+ " EL: "+str(round(self.res_ele, 1)), transform=caax.transAxes, va='bottom',ha='right')
                     self.ini= self.ini+1
             class WeatherRHIPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'rhistyle'
                 buffering = False
                 data_ele_tmp = None
                 def setup(self):
                     print("********************")
                     print("********************")
                     print("********************")
                     print("SETUP WEATHER PLOT")
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     print("channels",self.channels)
                     print("que saldra", self.data.shape(self.CODE)[0])
                     self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
                     print("self.titles",self.titles)
                     self.colorbar=False
                     self.width   =12
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     print("dataOut",dataOut.data_360.shape)
                     #
                     data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
                     #
                     #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     #print("UPDATE")
                     #print("data[weather]",data['weather'].shape)
                     #print("data[azi]",data['azi'])
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
                             diff_ = angulos[i]-angulos[i-1]
                             if abs(diff_) >1.5:
                                 list1.append(i-1)
                                 list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData90(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+90
                         return ang_
                     return ang_
                 def fixData90HL(self,angulos):
                     vec = numpy.where(angulos>=90)
                     angulos[vec]=angulos[vec]-90
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(abs(list2_[i]))-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(abs(list2_[value]))-1):
                                 if tipo_case==0 or tipo_case==3:#subida
                                     ang_new[pos+k]  = ang_new[pos+k-1]+1
                                     ang_new2[pos+k] = numpy.nan
                                 elif tipo_case==1 or tipo_case==2:#bajada
                                     ang_new[pos+k]  = ang_new[pos+k-1]-1
                                     ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos,tipo_case):
                     l1,l2 = self.get2List(angulos)
                     ##print("l1",l1)
                     ##print("l2",l2)
                     if len(l1)>0:
                         #angulos2 = self.fixData90(list_=l1,ang_=angulos)
                         #l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
                         #ang1_ = self.fixData90HL(ang1_)
                         #ang2_ = self.fixData90HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def replaceNAN(self,data_weather,data_ele,val):
                     data= data_ele
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def check_case(self,data_ele,ang_max,ang_min):
                     start  = data_ele[0]
                     end    = data_ele[-1]
                     number = (end-start)
                     len_ang=len(data_ele)
                     print("start",start)
                     print("end",end)
                     print("number",number)
                     print("len_ang",len_ang)
                     #exit(1)
                     if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
                         return 0
                     #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
                     #    return 1
                     elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
                         return 1
                     elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
                         return 2
                     elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
                         return 3
                 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min):
                     ang_max= ang_max
                     ang_min= ang_min
                     data_weather=data_weather
                     val_ch=val_ch
                     ##print("*********************DATA WEATHER**************************************")
                     ##print(data_weather)
                     if self.ini==0:
                         '''
                         print("**********************************************")
                         print("**********************************************")
                         print("***************ini**************")
                         print("**********************************************")
                         print("**********************************************")
                         '''
                         #print("data_ele",data_ele)
                         #----------------------------------------------------------
                         tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         print("check_case",tipo_case)
                         #exit(1)
                         #--------------------- new -------------------------
                         data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
                         #-------------------------CAMBIOS RHI---------------------------------
                         start= ang_min
                         end  = ang_max
                         n= (ang_max-ang_min)/res
                         #------ new
                         self.start_data_ele = data_ele_new[0]
                         self.end_data_ele  = data_ele_new[-1]
                         if tipo_case==0  or tipo_case==3: # SUBIDA
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 print("ele1_nan",ele1_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 print("ele2_nan",ele2_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         if tipo_case==1  or tipo_case==2: # BAJADA
                             data_ele_new       = data_ele_new[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele_new<ang_max)
                             data_ele_new = data_ele_new[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele_new)
                             data_ele_new = data_ele_new[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             self.start_data_ele = data_ele_new[0]
                             self.end_data_ele  = data_ele_new[-1]
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)-1
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         # RADAR
                         # NOTA data_ele y data_weather es la variable que retorna
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         self.data_ele_tmp[val_ch]= data_ele_old
                     else:
                         #print("**********************************************")
                         #print("****************VARIABLE**********************")
                         #-------------------------CAMBIOS RHI---------------------------------
                         #---------------------------------------------------------------------
                         ##print("INPUT data_ele",data_ele)
                         flag=0
                         start_ele = self.res_ele[0]
                         tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         #print("TIPO DE DATA",tipo_case)
                         #-----------new------------
                         data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
                         data_weather           = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         #-------------------------------NEW RHI ITERATIVO-------------------------
                         if tipo_case==0 : # SUBIDA
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2 = numpy.where(0<data_ele)
                             data_ele= data_ele[vec2]
                             data_ele_old= data_ele_old[vec2]
                             ##print(data_ele_new)
                             data_weather= data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(new_i_ele)
                             #print(new_f_ele)
                             #print(data_ele,len(data_ele))
                             #print(data_ele_old,len(data_ele_old))
                             if new_i_ele< 2:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 self.res_weather[val_ch]  = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
                             self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
                             self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
                             self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==1 : #BAJADA
                             data_ele       = data_ele[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele)
                             data_ele = data_ele[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(data_ele)
                             #print(ang_max)
                             #print(data_ele_old)
                             if new_i_ele <= 1:
                                 new_i_ele = 1
                             if round(data_ele[-1])>=ang_max-1:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 self.res_weather[val_ch]  = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
                             self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
                             self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
                             self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
                             data_ele     = self.res_ele
                             data_weather = self.res_weather[val_ch]
                         elif tipo_case==2:  #bajada
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_weather= data_weather[vec[0]]
                             len_vec = len(vec)
                             data_ele_new     = data_ele[::-1] #  reversa
                             data_weather =  data_weather[::-1,:]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==3:#subida
                             vec = numpy.where(0<data_ele)
                             data_ele= data_ele[vec]
                             data_ele_new = data_ele
                             data_ele_old= data_ele_old[vec]
                             data_weather= data_weather[vec[0]]
                             pos_ini = numpy.argmin(data_ele)
                             if pos_ini>0:
                                 len_vec= len(data_ele)
                                 vec3  = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
                                 #print(vec3)
                                 data_ele= data_ele[vec3]
                                 data_ele_new = data_ele
                                 data_ele_old= data_ele_old[vec3]
                                 data_weather= data_weather[vec3]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                     #print("self.data_ele_tmp",self.data_ele_tmp)
                     return data_weather,data_ele
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     ##print("delta_height",delta_height)
                     #print("r_mask",r_mask,len(r_mask))
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     res          = 1
                     ###print("data['weather'].shape[0]",data['weather'].shape[0])
                     ang_max = self.ang_max
                     ang_min = self.ang_min
                     var_ang      =ang_max -  ang_min
                     step         = (int(var_ang)/(res*data['weather'].shape[0]))
                     ###print("step",step)
                     #--------------------------------------------------------
                     ##print('weather',data['weather'].shape)
                     ##print('ele',data['ele'].shape)
                     ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
                     ###self.res_azi                   = numpy.mean(data['azi'])
                     ###print("self.res_ele",self.res_ele)
                     plt.clf()
                     subplots = [121, 122]
                     cg={'angular_spacing': 20.}
                     if self.ini==0:
                         self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
                         self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
                         print("SHAPE",self.data_ele_tmp.shape)
                     for i,ax in enumerate(self.axes):
                         self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
                         self.res_azi                   = numpy.mean(data['azi'])
                         if i==0:
                             print("*****************************************************************************to plot**************************",self.res_weather[i].shape)
                         self.zmin = self.zmin if self.zmin else 20
                         self.zmax = self.zmax if self.zmax else 80
                         if ax.firsttime:
                             #plt.clf()
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
                             #fig=self.figures[0]
                         else:
                             #plt.clf()
                             if i==0:
                                 print(self.res_weather[i])
                                 print(self.res_ele)
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj=cg,vmin=self.zmin, vmax=self.zmax)
                         caax = cgax.parasites[0]
                         paax = cgax.parasites[1]
                         cbar = plt.gcf().colorbar(pm, pad=0.075)
                         caax.set_xlabel('x_range [km]')
                         caax.set_ylabel('y_range [km]')
                         plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+"  Step   "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
                     print("***************************self.ini****************************",self.ini)
                     self.ini= self.ini+1
             class Weather_vRF_Plot(Plot):
                 CODE = 'PPI'
                 plot_name = 'PPI'
                 #plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width   =8
                     self.height  =8
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.xlabel= 'Range [Km]'
                     self.titles= ['PPI']
                     self.polar = True
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.CODE == 'POWER':
                         self.cb_label = r'Power (dB)'
                     elif self.CODE == 'DOPPLER':
                         self.cb_label = r'Velocity (m/s)'
                     self.colorbar=True
                     self.width  = 9
                     self.height  =8
                     self.ini  =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.15, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     if 'pow' in self.attr_data[0].lower():
                         data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
                     else:
                         data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def plot(self):
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     self.r_mask = r_mask
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     try:
                         z = data['data'][self.channels[0]][:,r_mask]
                     except:
                         z = data['data'][0][:,r_mask]
                     self.titles = []
                     self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
                     self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                     self.ang_min = self.ang_min if self.ang_min else 0
                     self.ang_max = self.ang_max if self.ang_max else 360
                     r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             ax.set_theta_direction(-1)
                         else:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             ax.set_theta_direction(-1)
                         ax.grid(True)
                         if len(self.channels) !=1:
                             self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(numpy.mean(data['ele']),1)), x) for x in range(self.nrows)]
                         else:
                             self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['ele']),1)), self.channels[0])]
             class WeatherRHI_vRF2_Plot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'rhistyle'
                 buffering = False
                 data_ele_tmp = None
                 def setup(self):
                     print("********************")
                     print("********************")
                     print("********************")
                     print("SETUP WEATHER PLOT")
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.titles= ['Weather']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     print("channels",self.channels)
                     print("que saldra", self.data.shape(self.CODE)[0])
                     self.titles = ['{} Channel {}'.format(self.CODE.upper(), x) for x in range(self.nrows)]
                     print("self.titles",self.titles)
                     self.colorbar=False
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     print("dataOut",dataOut.data_360.shape)
                     #
                     data['weather'] = 10*numpy.log10(dataOut.data_360/(factor))
                     #
                     #data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     data['case_flag']     = dataOut.case_flag
                     #print("UPDATE")
                     #print("data[weather]",data['weather'].shape)
                     #print("data[azi]",data['azi'])
                     return data, meta
                 def get2List(self,angulos):
                     list1=[]
                     list2=[]
                     for i in reversed(range(len(angulos))):
                         if not i==0:#el caso de i=0 evalula el primero de la lista con el ultimo y no es relevante
                             diff_ = angulos[i]-angulos[i-1]
                             if abs(diff_) >1.5:
                                 list1.append(i-1)
                                 list2.append(diff_)
                     return list(reversed(list1)),list(reversed(list2))
                 def fixData90(self,list_,ang_):
                     if list_[0]==-1:
                         vec = numpy.where(ang_<ang_[0])
                         ang_[vec] = ang_[vec]+90
                         return ang_
                     return ang_
                 def fixData90HL(self,angulos):
                     vec = numpy.where(angulos>=90)
                     angulos[vec]=angulos[vec]-90
                     return angulos
                 def search_pos(self,pos,list_):
                     for i in range(len(list_)):
                         if pos == list_[i]:
                             return True,i
                     i=None
                     return False,i
                 def fixDataComp(self,ang_,list1_,list2_,tipo_case):
                     size  = len(ang_)
                     size2 = 0
                     for i in range(len(list2_)):
                         size2=size2+round(abs(list2_[i]))-1
                     new_size= size+size2
                     ang_new = numpy.zeros(new_size)
                     ang_new2 = numpy.zeros(new_size)
                     tmp = 0
                     c   = 0
                     for i in range(len(ang_)):
                         ang_new[tmp +c] = ang_[i]
                         ang_new2[tmp+c] = ang_[i]
                         condition , value = self.search_pos(i,list1_)
                         if condition:
                             pos = tmp + c + 1
                             for k in range(round(abs(list2_[value]))-1):
                                 if tipo_case==0 or tipo_case==3:#subida
                                     ang_new[pos+k]  = ang_new[pos+k-1]+1
                                     ang_new2[pos+k] = numpy.nan
                                 elif tipo_case==1 or tipo_case==2:#bajada
                                     ang_new[pos+k]  = ang_new[pos+k-1]-1
                                     ang_new2[pos+k] = numpy.nan
                             tmp = pos +k
                             c   = 0
                         c=c+1
                     return ang_new,ang_new2
                 def globalCheckPED(self,angulos,tipo_case):
                     l1,l2 = self.get2List(angulos)
                     ##print("l1",l1)
                     ##print("l2",l2)
                     if len(l1)>0:
                         #angulos2 = self.fixData90(list_=l1,ang_=angulos)
                         #l1,l2 = self.get2List(angulos2)
                         ang1_,ang2_ = self.fixDataComp(ang_=angulos,list1_=l1,list2_=l2,tipo_case=tipo_case)
                         #ang1_ = self.fixData90HL(ang1_)
                         #ang2_ = self.fixData90HL(ang2_)
                     else:
                         ang1_= angulos
                         ang2_= angulos
                     return ang1_,ang2_
                 def replaceNAN(self,data_weather,data_ele,val):
                     data= data_ele
                     data_T= data_weather
                     if data.shape[0]> data_T.shape[0]:
                         data_N = numpy.ones( [data.shape[0],data_T.shape[1]])
                         c      = 0
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                 data_N[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                             else:
                                 data_N[i,:]=data_T[c,:]
                                 c=c+1
                         return data_N
                     else:
                         for i in range(len(data)):
                             if numpy.isnan(data[i]):
                                data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
                         return data_T
                 def check_case(self,data_ele,ang_max,ang_min):
                     start  = data_ele[0]
                     end    = data_ele[-1]
                     number = (end-start)
                     len_ang=len(data_ele)
                     print("start",start)
                     print("end",end)
                     print("number",number)
                     print("len_ang",len_ang)
                     #exit(1)
                     if start<end and (round(abs(number)+1)>=len_ang or (numpy.argmin(data_ele)==0)):#caso subida
                         return 0
                     #elif start>end and (round(abs(number)+1)>=len_ang or(numpy.argmax(data_ele)==0)):#caso bajada
                     #    return 1
                     elif round(abs(number)+1)>=len_ang and (start>end or(numpy.argmax(data_ele)==0)):#caso bajada
                         return 1
                     elif round(abs(number)+1)<len_ang and data_ele[-2]>data_ele[-1]:# caso BAJADA CAMBIO ANG MAX
                         return 2
                     elif round(abs(number)+1)<len_ang and data_ele[-2]<data_ele[-1] :# caso SUBIDA CAMBIO ANG MIN
                         return 3
                 def const_ploteo(self,val_ch,data_weather,data_ele,step,res,ang_max,ang_min,case_flag):
                     ang_max= ang_max
                     ang_min= ang_min
                     data_weather=data_weather
                     val_ch=val_ch
                     ##print("*********************DATA WEATHER**************************************")
                     ##print(data_weather)
                     if self.ini==0:
                         '''
                         print("**********************************************")
                         print("**********************************************")
                         print("***************ini**************")
                         print("**********************************************")
                         print("**********************************************")
                         '''
                         #print("data_ele",data_ele)
                         #----------------------------------------------------------
                         tipo_case = case_flag[-1]
                         #tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         print("check_case",tipo_case)
                         #exit(1)
                         #--------------------- new -------------------------
                         data_ele_new ,data_ele_old= self.globalCheckPED(data_ele,tipo_case)
                         #-------------------------CAMBIOS RHI---------------------------------
                         start= ang_min
                         end  = ang_max
                         n= (ang_max-ang_min)/res
                         #------ new
                         self.start_data_ele = data_ele_new[0]
                         self.end_data_ele  = data_ele_new[-1]
                         if tipo_case==0  or tipo_case==3: # SUBIDA
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 print("ele1_nan",ele1_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 print("ele2_nan",ele2_nan.shape)
                                 print("data_ele_old",data_ele_old.shape)
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         if tipo_case==1  or tipo_case==2: # BAJADA
                             data_ele_new       = data_ele_new[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele_new<ang_max)
                             data_ele_new = data_ele_new[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele_new)
                             data_ele_new = data_ele_new[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             self.start_data_ele = data_ele_new[0]
                             self.end_data_ele  = data_ele_new[-1]
                             n1= round(self.start_data_ele)- start
                             n2= end - round(self.end_data_ele)-1
                             print(self.start_data_ele)
                             print(self.end_data_ele)
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,self.start_data_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_old))
                             if n2>0:
                                 ele2= numpy.linspace(self.end_data_ele+1,end,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                         # RADAR
                         # NOTA data_ele y data_weather es la variable que retorna
                         val_mean         = numpy.mean(data_weather[:,-1])
                         self.val_mean    = val_mean
                         data_weather     = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         print("eleold",data_ele_old)
                         print(self.data_ele_tmp[val_ch])
                         print(data_ele_old.shape[0])
                         print(self.data_ele_tmp[val_ch].shape[0])
                         if (data_ele_old.shape[0]==91 or self.data_ele_tmp[val_ch].shape[0]==91):
                             import sys
                             print("EXIT",self.ini)
                             sys.exit(1)
                         self.data_ele_tmp[val_ch]= data_ele_old
                     else:
                         #print("**********************************************")
                         #print("****************VARIABLE**********************")
                         #-------------------------CAMBIOS RHI---------------------------------
                         #---------------------------------------------------------------------
                         ##print("INPUT data_ele",data_ele)
                         flag=0
                         start_ele = self.res_ele[0]
                         #tipo_case = self.check_case(data_ele,ang_max,ang_min)
                         tipo_case = case_flag[-1]
                         #print("TIPO DE DATA",tipo_case)
                         #-----------new------------
                         data_ele ,data_ele_old = self.globalCheckPED(data_ele,tipo_case)
                         data_weather           = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                         #-------------------------------NEW RHI ITERATIVO-------------------------
                         if tipo_case==0 : # SUBIDA
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2 = numpy.where(0<data_ele)
                             data_ele= data_ele[vec2]
                             data_ele_old= data_ele_old[vec2]
                             ##print(data_ele_new)
                             data_weather= data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(new_i_ele)
                             #print(new_f_ele)
                             #print(data_ele,len(data_ele))
                             #print(data_ele_old,len(data_ele_old))
                             if new_i_ele< 2:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 self.res_weather[val_ch]  = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
                             self.data_ele_tmp[val_ch][new_i_ele:new_i_ele+len(data_ele)]=data_ele_old
                             self.res_ele[new_i_ele:new_i_ele+len(data_ele)]= data_ele
                             self.res_weather[val_ch][new_i_ele:new_i_ele+len(data_ele),:]= data_weather
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==1 : #BAJADA
                             data_ele       = data_ele[::-1] #  reversa
                             data_ele_old   = data_ele_old[::-1]# reversa
                             data_weather   = data_weather[::-1,:]# reversa
                             vec= numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_ele_old = data_ele_old[vec]
                             data_weather  = data_weather[vec[0]]
                             vec2= numpy.where(0<data_ele)
                             data_ele = data_ele[vec2]
                             data_ele_old = data_ele_old[vec2]
                             data_weather  = data_weather[vec2[0]]
                             new_i_ele  = int(round(data_ele[0]))
                             new_f_ele  = int(round(data_ele[-1]))
                             #print(data_ele)
                             #print(ang_max)
                             #print(data_ele_old)
                             if new_i_ele <= 1:
                                 new_i_ele = 1
                             if round(data_ele[-1])>=ang_max-1:
                                 self.data_ele_tmp[val_ch] = numpy.ones(ang_max-ang_min)*numpy.nan
                                 self.res_weather[val_ch]  = self.replaceNAN(data_weather=self.res_weather[val_ch],data_ele=self.data_ele_tmp[val_ch],val=self.val_mean)
                             self.data_ele_tmp[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1]=data_ele_old
                             self.res_ele[new_i_ele-1:new_i_ele+len(data_ele)-1]= data_ele
                             self.res_weather[val_ch][new_i_ele-1:new_i_ele+len(data_ele)-1,:]= data_weather
                             data_ele     = self.res_ele
                             data_weather = self.res_weather[val_ch]
                         elif tipo_case==2:  #bajada
                             vec = numpy.where(data_ele<ang_max)
                             data_ele = data_ele[vec]
                             data_weather= data_weather[vec[0]]
                             len_vec = len(vec)
                             data_ele_new     = data_ele[::-1] #  reversa
                             data_weather =  data_weather[::-1,:]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                         elif tipo_case==3:#subida
                             vec = numpy.where(0<data_ele)
                             data_ele= data_ele[vec]
                             data_ele_new = data_ele
                             data_ele_old= data_ele_old[vec]
                             data_weather= data_weather[vec[0]]
                             pos_ini = numpy.argmin(data_ele)
                             if pos_ini>0:
                                 len_vec= len(data_ele)
                                 vec3  = numpy.linspace(pos_ini,len_vec-1,len_vec-pos_ini).astype(int)
                                 #print(vec3)
                                 data_ele= data_ele[vec3]
                                 data_ele_new = data_ele
                                 data_ele_old= data_ele_old[vec3]
                                 data_weather= data_weather[vec3]
                             new_i_ele  = int(data_ele_new[0])
                             new_f_ele  = int(data_ele_new[-1])
                             n1= new_i_ele- ang_min
                             n2= ang_max - new_f_ele-1
                             if n1>0:
                                 ele1= numpy.linspace(ang_min+1,new_i_ele-1,n1)
                                 ele1_nan= numpy.ones(n1)*numpy.nan
                                 data_ele = numpy.hstack((ele1,data_ele_new))
                                 data_ele_old = numpy.hstack((ele1_nan,data_ele_new))
                             if n2>0:
                                 ele2= numpy.linspace(new_f_ele+1,ang_max,n2)
                                 ele2_nan= numpy.ones(n2)*numpy.nan
                                 data_ele = numpy.hstack((data_ele,ele2))
                                 data_ele_old = numpy.hstack((data_ele_old,ele2_nan))
                             self.data_ele_tmp[val_ch] = data_ele_old
                             self.res_ele      = data_ele
                             self.res_weather[val_ch]  = self.replaceNAN(data_weather=data_weather,data_ele=data_ele_old,val=self.val_mean)
                             data_ele                                    = self.res_ele
                             data_weather                                = self.res_weather[val_ch]
                     #print("self.data_ele_tmp",self.data_ele_tmp)
                     return data_weather,data_ele
                 def plot(self):
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     ##print("delta_height",delta_height)
                     #print("r_mask",r_mask,len(r_mask))
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     res          = 1
                     ###print("data['weather'].shape[0]",data['weather'].shape[0])
                     ang_max = self.ang_max
                     ang_min = self.ang_min
                     var_ang      =ang_max -  ang_min
                     step         = (int(var_ang)/(res*data['weather'].shape[0]))
                     ###print("step",step)
                     #--------------------------------------------------------
                     ##print('weather',data['weather'].shape)
                     ##print('ele',data['ele'].shape)
                     ###self.res_weather, self.res_ele = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min)
                     ###self.res_azi                   = numpy.mean(data['azi'])
                     ###print("self.res_ele",self.res_ele)
                     plt.clf()
                     subplots = [121, 122]
                     try:
                         if self.data[-2]['ele'].max()<data['ele'].max():
                             self.ini=0
                     except:
                         pass
                     if self.ini==0:
                         self.data_ele_tmp = numpy.ones([self.nplots,int(var_ang)])*numpy.nan
                         self.res_weather= numpy.ones([self.nplots,int(var_ang),len(r_mask)])*numpy.nan
                         print("SHAPE",self.data_ele_tmp.shape)
                     for i,ax in enumerate(self.axes):
                         self.res_weather[i], self.res_ele = self.const_ploteo(val_ch=i, data_weather=data['weather'][i][:,r_mask],data_ele=data['ele'],step=step,res=res,ang_max=ang_max,ang_min=ang_min,case_flag=self.data['case_flag'])
                         self.res_azi                   = numpy.mean(data['azi'])
                         if ax.firsttime:
                             #plt.clf()
                             print("Frist Plot")
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
                             #fig=self.figures[0]
                         else:
                             #plt.clf()
                             print("ELSE PLOT")
                             cgax, pm = wrl.vis.plot_rhi(self.res_weather[i],r=r,th=self.res_ele,ax=subplots[i], proj='cg',vmin=20, vmax=80)
                         caax = cgax.parasites[0]
                         paax = cgax.parasites[1]
                         cbar = plt.gcf().colorbar(pm, pad=0.075)
                         caax.set_xlabel('x_range [km]')
                         caax.set_ylabel('y_range [km]')
                         plt.text(1.0, 1.05, 'Elevacion '+str(thisDatetime)+"  Step   "+str(self.ini)+ " Azi: "+str(round(self.res_azi,2)), transform=caax.transAxes, va='bottom',ha='right')
                     print("***************************self.ini****************************",self.ini)
                     self.ini= self.ini+1
             class WeatherRHI_vRF4_Plot(Plot):
                 CODE = 'RHI'
                 plot_name = 'RHI'
                 #plot_type = 'rhistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [Km]'
                     self.xlabel= 'Range [Km]'
                     self.titles= ['RHI']
                     self.polar = True
                     self.grid = True
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.CODE == 'Power':
                         self.cb_label = r'Power (dB)'
                     elif self.CODE == 'Doppler':
                         self.cb_label = r'Velocity (m/s)'
                     self.colorbar=True
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     if 'pow' in self.attr_data[0].lower():
                         data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
                     else:
                         data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     return data, meta
                 def plot(self):
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     self.r_mask =r_mask
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     try:
                         z = data['data'][self.channels[0]][:,r_mask]
                     except:
                         z = data['data'][0][:,r_mask]
                     self.titles = []
                     self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
                     self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                     self.ang_min = self.ang_min if self.ang_min else 0
                     self.ang_max = self.ang_max if self.ang_max else 90
                     r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                         else:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                         ax.grid(True)
                         if len(self.channels) !=1:
                             self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(numpy.mean(data['azi']),1)), x) for x in range(self.nrows)]
                         else:
                             self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(numpy.mean(data['azi']),1)), self.channels[0])]
             class WeatherParamsPlot(Plot):
                 #CODE = 'RHI'
                 #plot_name = 'RHI'
                 #plot_type = 'rhistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     self.ylabel= 'Range [km]'
                     self.xlabel= 'Range [km]'
                     self.polar = True
                     self.grid = True
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     self.colorbar=True
                     self.width   =8
                     self.height  =8
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
-                    self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.08, 'right': 0.92, 'bottom': 0.01,'top':0.99})
+                    self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     if 'pow' in self.attr_data[0].lower():
                         data['data'] = 10*numpy.log10(getattr(dataOut, self.attr_data[0])/(factor))
                     else:
                         data['data'] = getattr(dataOut, self.attr_data[0])/(factor)
                     if dataOut.mode_op == 'PPI':
                         self.CODE = 'PPI'
                         self.title = self.CODE
                     elif dataOut.mode_op == 'RHI':
                         self.CODE = 'RHI'
                         self.title = self.CODE
                     data['azi']     = dataOut.data_azi
                     data['ele']     = dataOut.data_ele
                     data['mode_op'] = dataOut.mode_op
                     return data, meta
                 def plot(self):
                     data         = self.data[-1]
                     r            = self.data.yrange
                     delta_height = r[1]-r[0]
                     r_mask       = numpy.where(r>=0)[0]
                     self.r_mask =r_mask
                     r            = numpy.arange(len(r_mask))*delta_height
                     self.y       = 2*r
                     try:
                         z = data['data'][self.channels[0]][:,r_mask]
                     except:
                         z = data['data'][0][:,r_mask]
                     self.titles = []
                     self.ymax = self.ymax if self.ymax else numpy.nanmax(r)
                     self.ymin = self.ymin if self.ymin else numpy.nanmin(r)
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                     print("mode inside plot",self.data['mode_op'],data['mode_op'])
                     if data['mode_op'] == 'RHI':
                         try:
                             if self.data['mode_op'][-2] == 'PPI':
                                 self.ang_min = None
                                 self.ang_max = None
                         except:
                             pass
                         self.ang_min = self.ang_min if self.ang_min else 0
                         self.ang_max = self.ang_max if self.ang_max else 90
                         r, theta = numpy.meshgrid(r, numpy.radians(data['ele']) )
                     elif data['mode_op'] == 'PPI':
                         try:
                             if self.data['mode_op'][-2] == 'RHI':
                                 self.ang_min = None
                                 self.ang_max = None
                         except:
                             pass
                         self.ang_min = self.ang_min if self.ang_min else 0
                         self.ang_max = self.ang_max if self.ang_max else 360
                         r, theta = numpy.meshgrid(r, numpy.radians(data['azi']) )
                     self.clear_figures()
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             if data['mode_op'] == 'PPI':
                                 ax.set_theta_direction(-1)
                                 ax.set_theta_offset(numpy.pi/2)
                         else:
                             ax.set_xlim(numpy.radians(self.ang_min),numpy.radians(self.ang_max))
                             ax.plt = ax.pcolormesh(theta, r, z, cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                             if data['mode_op'] == 'PPI':
                                 ax.set_theta_direction(-1)
                                 ax.set_theta_offset(numpy.pi/2)
                         ax.grid(True)
                         if data['mode_op'] == 'RHI':
                             len_aux = int(data['azi'].shape[0]/4)
                             mean = numpy.mean(data['azi'][len_aux:-len_aux])
                             if len(self.channels) !=1:
                                 self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
                             else:
                                 self.titles = ['RHI {} at AZ: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
                         elif data['mode_op'] == 'PPI':
                             len_aux = int(data['ele'].shape[0]/4)
                             mean = numpy.mean(data['ele'][len_aux:-len_aux])
                             if len(self.channels) !=1:
                                 self.titles = ['PPI {} at EL: {} Channel {}'.format(self.self.labels[x], str(round(mean,1)), x) for x in range(self.nrows)]
                             else:
                                 self.titles = ['PPI {} at EL: {} Channel {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]

schainpy/scripts/sophy_proc_ch0.py +6 -5

             # SOPHY PROC script
             import os, sys, json, argparse
             import datetime
             import time
             PATH = '/DATA_RM/DATA'
             # PATH = '/Users/jespinoza/workspace/data/'
-            PATH = '/home/soporte/Documents/HUANCAYO'
+            #PATH = '/home/soporte/Documents/HUANCAYO'
             PARAM = {
-                'P': {'name': 'dataPP_POWER', 'zmin': -40, 'zmax': -5, 'colormap': 'jet', 'label': 'Power', 'wrname': 'Pow','cb_label': 'dB', 'ch':0},
+                'P': {'name': 'dataPP_POWER', 'zmin': -45, 'zmax': -25, 'colormap': 'jet', 'label': 'Power', 'wrname': 'Pow','cb_label': 'dB', 'ch':0},
                 'V': {'name': 'dataPP_DOP', 'zmin': -20, 'zmax': 20, 'colormap': 'seismic', 'label': 'Velocity', 'wrname': 'Vel', 'cb_label': 'm/s', 'ch':0},
                 'RH': {'name': 'RhoHV_R', 'zmin': 0,   'zmax': 1,  'colormap': 'jet',    'label': 'Coef.Correlacion', 'wrname':'R', 'cb_label': '*',  'ch':0},
                 'FD': {'name': 'PhiD_P', 'zmin': -180,'zmax': 180,'colormap': 'RdBu_r', 'label': 'Fase Diferencial', 'wrname':'P' , 'cb_label': 'º',  'ch':0},
                 'ZD': {'name': 'Zdb_D', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis','label': 'Reflect.Diferencial','wrname':'D' , 'cb_label': 'dBz','ch':0},
                 'Z':  {'name': 'Zdb', 'zmin': -20, 'zmax': 70, 'colormap': 'gist_ncar','label': 'Reflectividad',  'wrname':'Z', 'cb_label': 'dBz','ch':1},
                 'W':  {'name': 'Sigmav_W', 'zmin': 0, 'zmax':5, 'colormap': 'viridis','label': 'AnchoEspectral', 'wrname':'S', 'cb_label': 'hz', 'ch':1}
                 }
             #
             def max_index(r, sample_rate, ipp):
                 return int(sample_rate*ipp*1e6 * r / 60) + int(sample_rate*ipp*1e6 * 1.2 / 60)
             def main(args):
                 experiment = args.experiment
                 fp = open(os.path.join(PATH, experiment, 'experiment.conf'))
                 conf = json.loads(fp.read())
                 ipp_km = conf['usrp_tx']['ipp']
                 ipp = ipp_km * 2 /300000
                 sample_rate  = conf['usrp_rx']['sample_rate']
                 axis = ['0' if x=='elevation' else '1' for x in conf['pedestal']['axis']]      # AZIMUTH 1 ELEVACION 0
                 speed_axis = conf['pedestal']['speed']
                 steeps = conf['pedestal']['table']
                 time_offset = args.time_offset
                 parameters = args.parameters
                 start_date = experiment.split('@')[1].split('T')[0].replace('-', '/')
                 end_date = start_date
                 start_time = experiment.split('@')[1].split('T')[1].replace('-', ':')
                 end_time = '23:59:59'
                 N = int(1/(speed_axis[0]*ipp))                                               # 1 GRADO DE RESOLUCION
                 path = os.path.join(PATH, experiment, 'rawdata')
                 path_ped = os.path.join(PATH, experiment, 'position')
                 path_plots = os.path.join(PATH, experiment, 'plots_ch0')
                 path_save = os.path.join(PATH, experiment, 'param')
-                RMIX = 10
+                RMIX = 20
                 from schainpy.controller import Project
                 project = Project()
                 project.setup(id='1', name='Sophy', description='sophy proc')
                 reader = project.addReadUnit(datatype='DigitalRFReader',
                     path=path,
                     startDate=start_date,
                     endDate=end_date,
                     startTime=start_time,
                     endTime=end_time,
                     delay=30,
                     channelList='0',
                     online=args.online,
                     walk=1,
                     ippKm = ipp_km,
                     getByBlock = 1,
                     nProfileBlocks = N,
                 )
                 if not conf['usrp_tx']['enable_2']: # One Pulse
                     voltage = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     if conf['usrp_tx']['code_type_1']:
                         code = [c.split() for c in conf['usrp']['code_1']]
                         op = voltage.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                     op = voltage.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         op = voltage.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     code=[[1]]
                     opObj11 = voltage.addOperation(name='Decoder', optype='other')
                     opObj11.addParameter(name='code', value=code)
                     opObj11.addParameter(name='nCode', value='1', format='int')
                     opObj11.addParameter(name='nBaud', value='1', format='int')
                     op = voltage2.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                     op.addParameter(name='n', value=2*len(code), format='int')
                     #op = voltage.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N), format='int')
                     if args.range >= 0:
                         op = voltage.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     op = voltage.addOperation(name='PulsePair_vRF', optype='other')
                     op.addParameter(name='n', value=125, format='int')
                     proc = project.addProcUnit(datatype='ParametersProc', inputId=voltage.getId())
                     #procUnitConfObjB.addParameter(name='runNextUnit', value=True)
                     opObj10 = proc.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,VelocidadRadial,AnchoEspectral')
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc.addOperation(name='Block360_vRF4')
                         #op.addParameter(name='axis', value=','.join(axis))
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                         op= proc.addOperation(name='WeatherParamsPlot')
                         if args.save: op.addParameter(name='save', value=path_plots, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='0,')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                         desc = {
                                 'Data': {
                                     PARAM[param]['name']: PARAM[param]['label'],
                                     'utctime': 'time'
                                 },
                                  'Metadata': {
                                     'heightList': 'range',
                                     'data_azi': 'azimuth',
                                     'data_ele': 'elevation',
                                 }
                             }
                         if args.save:
                             opObj10 = proc.addOperation(name='HDFWriter')
                             opObj10.addParameter(name='path',value=path_save+'-{}'.format(param), format='str')
                             opObj10.addParameter(name='Reset',value=True)
                             opObj10.addParameter(name='setType',value='weather')
                             opObj10.addParameter(name='description',value='desc')
                             opObj10.addParameter(name='blocksPerFile',value='1',format='int')
                             opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
                             opObj10.addParameter(name='dataList',value='{},utctime'.format(PARAM[param]['name']))
                 else: #Two pulses
                     voltage1 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     print("repetions",conf['usrp_tx']['repetitions_1'])
                     op = voltage1.addOperation(name='ProfileSelector')
                     op.addParameter(name='profileRangeList', value='0,{}'.format(conf['usrp_tx']['repetitions_1']-1))
                     #op3 = voltage1.addOperation(name='ProfileSelector', optype='other')
                     #op3.addParameter(name='profileRangeList', value='1,123')
                     '''
                     if conf['usrp_tx']['code_type_1'] != 'None':
                         code = [c.split() for c in conf['usrp_tx']['code_1']]
                         op = voltage1.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                     '''
                     code=[[1]]
                     opObj11 = voltage1.addOperation(name='Decoder', optype='other')
                     opObj11.addParameter(name='code', value=code)
                     opObj11.addParameter(name='nCode', value='1', format='int')
                     opObj11.addParameter(name='nBaud', value='1', format='int')
                     op = voltage1.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         op = voltage1.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     op = voltage1.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                     op.addParameter(name='n', value=2, format='int')
                     op = voltage1.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N), format='int')
                     op.addParameter(name='n', value=61, format='int')
                     #op.addParameter(name='removeDC',value=True)
                     '''
                     if args.range >= 0:
                         print("corto",max_index(RMIX, sample_rate, ipp))
                         op = voltage1.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     '''
                     proc1 = project.addProcUnit(datatype='ParametersProc', inputId=voltage1.getId())
                     proc1.addParameter(name='runNextUnit', value=True)
                     opObj10 = proc1.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,VelocidadRadial,AnchoEspectral')
                     opObj10.addParameter(name='tauW',value=0.4*1e-6)
                     opObj10.addParameter(name='Pt',value=0.2)
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc1.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc1.addOperation(name='Block360_vRF4')
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                     voltage2 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     op = voltage2.addOperation(name='ProfileSelector')
                     op.addParameter(name='profileRangeList', value='{},{}'.format(conf['usrp_tx']['repetitions_1'], conf['usrp_tx']['repetitions_1']+conf['usrp_tx']['repetitions_2']-1))
                     if conf['usrp_tx']['code_type_2']:
                         print(conf['usrp_tx']['code_2'])
                         codes = [ c.strip() for c in conf['usrp_tx']['code_2'].split(',')]
                         code = []
                         for c in codes:
                             code.append([int(x) for x in c])
                         print(code)
                         print(code[0])
                         op = voltage2.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                         import numpy
                         pwcode = numpy.sum(numpy.array(code[0])**2)
                         print("pwcode",pwcode)
                         op = voltage2.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                         op.addParameter(name='n', value=len(code), format='int')
                         ncode = len(code)
                     else:
                         ncode = 1
                     op = voltage2.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         if args.range==0:
                             args.range= ipp_km
                         op = voltage2.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                         op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp), format='int')
                     #op = voltage2.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N)/ncode, format='int')
                     op = voltage2.addOperation(name='PulsePair_vRF', optype='other')
                     op.addParameter(name='n', value=64, format='int')
                     #op.addParameter(name='removeDC',value=True)
                     '''
                     if args.range >= 0:
                         if args.range==0:
                             args.range= ipp_km
                         op = voltage2.addOperation(name='selectHeights')
                         print("largo",max_index(RMIX, sample_rate, ipp))
                         print("largo2",max_index(args.range, sample_rate, ipp))
                         op.addParameter(name='minIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                         op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp), format='int')
                     '''
                     proc2 = project.addProcUnit(datatype='ParametersProc', inputId=voltage2.getId())
                     opObj10 = proc2.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,AnchoEspectral')
-                    opObj10.addParameter(name='tauW',value=3.2*1e-6)
+                    opObj10.addParameter(name='tauW',value=6.3*1e-6)
-                    opObj10.addParameter(name='Pt',value=1.6)
+                    opObj10.addParameter(name='Pt',value=3.2)
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc2.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc2.addOperation(name='Block360_vRF4')
                         #op.addParameter(name='axis', value=','.join(axis))
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                         merge = project.addProcUnit(datatype='MergeProc', inputId=[proc1.getId(), proc2.getId()])
                         merge.addParameter(name='attr_data', value=PARAM[param]['name'])
                         merge.addParameter(name='mode', value='7') #RM
                         op= merge.addOperation(name='WeatherParamsPlot')
                         if args.save: op.addParameter(name='save', value=path_plots, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='0,')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                         desc = {
                                 'Data': {
                                     PARAM[param]['name']: PARAM[param]['label'],
                                     'utctime': 'time'
                                 },
                                  'Metadata': {
                                     'heightList': 'range',
                                     'data_azi': 'azimuth',
                                     'data_ele': 'elevation',
                                 }
                             }
                         if args.save:
                             opObj10 = merge.addOperation(name='HDFWriter')
                             opObj10.addParameter(name='path',value=path_save, format='str')
                             opObj10.addParameter(name='Reset',value=True)
                             opObj10.addParameter(name='setType',value='weather')
                             opObj10.addParameter(name='description',value='desc')
                             opObj10.addParameter(name='blocksPerFile',value='1',format='int')
                             opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
                             opObj10.addParameter(name='dataList',value='{},utctime'.format(PARAM[param]['name']))
                 project.start()
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
                 parser.add_argument('experiment',
                                     help='Experiment name')
                 parser.add_argument('--parameters', nargs='*', default=['P'],
                                     help='Variables to process: P, Z, V')
                 parser.add_argument('--time_offset', default=0,
                                     help='Fix time offset')
                 parser.add_argument('--range', default=0, type=float,
                                     help='Max range to plot')
                 parser.add_argument('--save', action='store_true',
                                     help='Create output files')
                 parser.add_argument('--show', action='store_true',
                                     help='Show matplotlib plot.')
                 parser.add_argument('--online', action='store_true',
                                     help='Set online mode.')
                 args = parser.parse_args()
                 main(args)

schainpy/scripts/sophy_proc_ch1.py +1 -1

             # SOPHY PROC script
             import os, sys, json, argparse
             import datetime
             import time
             PATH = '/DATA_RM/DATA'
             # PATH = '/Users/jespinoza/workspace/data/'
-            PATH = '/home/soporte/Documents/HUANCAYO'
+            #PATH = '/home/soporte/Documents/HUANCAYO'
             PARAM = {
                 'P': {'name': 'dataPP_POWER', 'zmin': -50, 'zmax': -15, 'colormap': 'jet', 'label': 'Power', 'wrname': 'Pow','cb_label': 'dB', 'ch':0},
                 'V': {'name': 'dataPP_DOP', 'zmin': -20, 'zmax': 20, 'colormap': 'seismic', 'label': 'Velocity', 'wrname': 'Vel', 'cb_label': 'm/s', 'ch':0},
                 'RH': {'name': 'RhoHV_R', 'zmin': 0,   'zmax': 1,  'colormap': 'jet',    'label': 'Coef.Correlacion', 'wrname':'R', 'cb_label': '*',  'ch':0},
                 'FD': {'name': 'PhiD_P', 'zmin': -180,'zmax': 180,'colormap': 'RdBu_r', 'label': 'Fase Diferencial', 'wrname':'P' , 'cb_label': 'º',  'ch':0},
                 'ZD': {'name': 'Zdb_D', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis','label': 'Reflect.Diferencial','wrname':'D' , 'cb_label': 'dBz','ch':0},
                 'Z':  {'name': 'Zdb', 'zmin': -20, 'zmax': 70, 'colormap': 'gist_ncar','label': 'Reflectividad',  'wrname':'Z', 'cb_label': 'dBz','ch':1},
                 'W':  {'name': 'Sigmav_W', 'zmin': 0, 'zmax':5, 'colormap': 'viridis','label': 'AnchoEspectral', 'wrname':'S', 'cb_label': 'hz', 'ch':1}
                 }
             def max_index(r, sample_rate, ipp):
                 return int(sample_rate*ipp*1e6 * r / 60) + int(sample_rate*ipp*1e6 * 1.2 / 60)
             def main(args):
                 experiment = args.experiment
                 fp = open(os.path.join(PATH, experiment, 'experiment.conf'))
                 conf = json.loads(fp.read())
                 ipp_km = conf['usrp_tx']['ipp']
                 ipp = ipp_km * 2 /300000
                 sample_rate  = conf['usrp_rx']['sample_rate']
                 axis = ['0' if x=='elevation' else '1' for x in conf['pedestal']['axis']]      # AZIMUTH 1 ELEVACION 0
                 speed_axis = conf['pedestal']['speed']
                 steeps = conf['pedestal']['table']
                 time_offset = args.time_offset
                 parameters = args.parameters
                 start_date = experiment.split('@')[1].split('T')[0].replace('-', '/')
                 end_date = start_date
                 start_time = experiment.split('@')[1].split('T')[1].replace('-', ':')
                 end_time = '23:59:59'
                 N = int(1/(speed_axis[0]*ipp))                                               # 1 GRADO DE RESOLUCION
                 path = os.path.join(PATH, experiment, 'rawdata')
                 path_ped = os.path.join(PATH, experiment, 'position')
                 path_plots = os.path.join(PATH, experiment, 'plots_ch1')
                 path_save = os.path.join(PATH, experiment, 'param')
                 RMIX = 2
                 from schainpy.controller import Project
                 project = Project()
                 project.setup(id='1', name='Sophy', description='sophy proc')
                 reader = project.addReadUnit(datatype='DigitalRFReader',
                     path=path,
                     startDate=start_date,
                     endDate=end_date,
                     startTime=start_time,
                     endTime=end_time,
                     delay=30,
                     channelList='0',
                     online=args.online,
                     walk=1,
                     ippKm = ipp_km,
                     getByBlock = 1,
                     nProfileBlocks = N,
                 )
                 if not conf['usrp_tx']['enable_2']: # One Pulse
                     voltage = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     if conf['usrp_tx']['code_type_1']:
                         code = [c.split() for c in conf['usrp']['code_1']]
                         op = voltage.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                     op = voltage.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         op = voltage.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     code=[[1]]
                     opObj11 = voltage.addOperation(name='Decoder', optype='other')
                     opObj11.addParameter(name='code', value=code)
                     opObj11.addParameter(name='nCode', value='1', format='int')
                     opObj11.addParameter(name='nBaud', value='1', format='int')
                     op = voltage2.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                     op.addParameter(name='n', value=2*len(code), format='int')
                     #op = voltage.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N), format='int')
                     if args.range >= 0:
                         op = voltage.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     op = voltage.addOperation(name='PulsePair_vRF', optype='other')
                     op.addParameter(name='n', value=125, format='int')
                     proc = project.addProcUnit(datatype='ParametersProc', inputId=voltage.getId())
                     #procUnitConfObjB.addParameter(name='runNextUnit', value=True)
                     opObj10 = proc.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,VelocidadRadial,AnchoEspectral')
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc.addOperation(name='Block360_vRF4')
                         #op.addParameter(name='axis', value=','.join(axis))
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                         op= proc.addOperation(name='WeatherParamsPlot')
                         if args.save: op.addParameter(name='save', value=path_plots, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='1,')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                         desc = {
                                 'Data': {
                                     PARAM[param]['name']: PARAM[param]['label'],
                                     'utctime': 'time'
                                 },
                                  'Metadata': {
                                     'heightList': 'range',
                                     'data_azi': 'azimuth',
                                     'data_ele': 'elevation',
                                 }
                             }
                         if args.save:
                             opObj10 = proc.addOperation(name='HDFWriter')
                             opObj10.addParameter(name='path',value=path_save+'-{}'.format(param), format='str')
                             opObj10.addParameter(name='Reset',value=True)
                             opObj10.addParameter(name='setType',value='weather')
                             opObj10.addParameter(name='description',value='desc')
                             opObj10.addParameter(name='blocksPerFile',value='1',format='int')
                             opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
                             opObj10.addParameter(name='dataList',value='{},utctime'.format(PARAM[param]['name']))
                 else: #Two pulses
                     voltage1 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     print("repetions",conf['usrp_tx']['repetitions_1'])
                     op = voltage1.addOperation(name='ProfileSelector')
                     op.addParameter(name='profileRangeList', value='0,{}'.format(conf['usrp_tx']['repetitions_1']-1))
                     #op3 = voltage1.addOperation(name='ProfileSelector', optype='other')
                     #op3.addParameter(name='profileRangeList', value='1,123')
                     '''
                     if conf['usrp_tx']['code_type_1'] != 'None':
                         code = [c.split() for c in conf['usrp_tx']['code_1']]
                         op = voltage1.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                     '''
                     code=[[1]]
                     opObj11 = voltage1.addOperation(name='Decoder', optype='other')
                     opObj11.addParameter(name='code', value=code)
                     opObj11.addParameter(name='nCode', value='1', format='int')
                     opObj11.addParameter(name='nBaud', value='1', format='int')
                     op = voltage1.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         op = voltage1.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     op = voltage1.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                     op.addParameter(name='n', value=2, format='int')
                     op = voltage1.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N), format='int')
                     op.addParameter(name='n', value=61, format='int')
                     #op.addParameter(name='removeDC',value=True)
                     '''
                     if args.range >= 0:
                         print("corto",max_index(RMIX, sample_rate, ipp))
                         op = voltage1.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value='0', format='int')
                         op.addParameter(name='maxIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                     '''
                     proc1 = project.addProcUnit(datatype='ParametersProc', inputId=voltage1.getId())
                     proc1.addParameter(name='runNextUnit', value=True)
                     opObj10 = proc1.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,VelocidadRadial,AnchoEspectral')
                     opObj10.addParameter(name='tauW',value=0.4*1e-6)
                     opObj10.addParameter(name='Pt',value=0.2)
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc1.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc1.addOperation(name='Block360_vRF4')
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                     voltage2 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
                     op = voltage2.addOperation(name='ProfileSelector')
                     op.addParameter(name='profileRangeList', value='{},{}'.format(conf['usrp_tx']['repetitions_1'], conf['usrp_tx']['repetitions_1']+conf['usrp_tx']['repetitions_2']-1))
                     if conf['usrp_tx']['code_type_2']:
                         print(conf['usrp_tx']['code_2'])
                         codes = [ c.strip() for c in conf['usrp_tx']['code_2'].split(',')]
                         code = []
                         for c in codes:
                             code.append([int(x) for x in c])
                         print(code)
                         print(code[0])
                         op = voltage2.addOperation(name='Decoder', optype='other')
                         op.addParameter(name='code', value=code)
                         op.addParameter(name='nCode', value=len(code), format='int')
                         op.addParameter(name='nBaud', value=len(code[0]), format='int')
                         import numpy
                         pwcode = numpy.sum(numpy.array(code[0])**2)
                         print("pwcode",pwcode)
                         op = voltage2.addOperation(name='CohInt', optype='other') #Minimo integrar 2 perfiles por ser codigo complementario
                         op.addParameter(name='n', value=len(code), format='int')
                         ncode = len(code)
                     else:
                         ncode = 1
                     op = voltage2.addOperation(name='setH0')
                     op.addParameter(name='h0', value='-1.2')
                     if args.range >= 0:
                         if args.range==0:
                             args.range= ipp_km
                         op = voltage2.addOperation(name='selectHeights')
                         op.addParameter(name='minIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                         op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp), format='int')
                     #op = voltage2.addOperation(name='PulsePair_vRF', optype='other')
                     #op.addParameter(name='n', value=int(N)/ncode, format='int')
                     op = voltage2.addOperation(name='PulsePair_vRF', optype='other')
                     op.addParameter(name='n', value=64, format='int')
                     #op.addParameter(name='removeDC',value=True)
                     '''
                     if args.range >= 0:
                         if args.range==0:
                             args.range= ipp_km
                         op = voltage2.addOperation(name='selectHeights')
                         print("largo",max_index(RMIX, sample_rate, ipp))
                         print("largo2",max_index(args.range, sample_rate, ipp))
                         op.addParameter(name='minIndex', value=max_index(RMIX, sample_rate, ipp), format='int')
                         op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp), format='int')
                     '''
                     proc2 = project.addProcUnit(datatype='ParametersProc', inputId=voltage2.getId())
                     opObj10 = proc2.addOperation(name="WeatherRadar")
                     opObj10.addParameter(name='variableList',value='Reflectividad,AnchoEspectral')
                     opObj10.addParameter(name='tauW',value=3.2*1e-6)
                     opObj10.addParameter(name='Pt',value=1.6)
                     # {"latitude": -12.0404828587, "longitude": -75.2147483647, "altitude": 3379.2147483647}
                     op = proc2.addOperation(name='PedestalInformation')
                     op.addParameter(name='path', value=path_ped, format='str')
                     op.addParameter(name='interval', value='0.04')
                     op.addParameter(name='time_offset', value=time_offset)
                     op.addParameter(name='az_offset', value=-26.2)
                     for param in parameters:
                         op = proc2.addOperation(name='Block360_vRF4')
                         #op.addParameter(name='axis', value=','.join(axis))
                         op.addParameter(name='attr_data', value=PARAM[param]['name'])
                         op.addParameter(name='runNextOp', value=True)
                         merge = project.addProcUnit(datatype='MergeProc', inputId=[proc1.getId(), proc2.getId()])
                         merge.addParameter(name='attr_data', value=PARAM[param]['name'])
                         merge.addParameter(name='mode', value='7') #RM
                         op= merge.addOperation(name='WeatherParamsPlot')
                         if args.save: op.addParameter(name='save', value=path_plots, format='str')
                         op.addParameter(name='save_period', value=-1)
                         op.addParameter(name='show', value=args.show)
                         op.addParameter(name='channels', value='1,')
                         op.addParameter(name='zmin', value=PARAM[param]['zmin'])
                         op.addParameter(name='zmax', value=PARAM[param]['zmax'])
                         op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
                         op.addParameter(name='labels', value=[PARAM[param]['label']])
                         op.addParameter(name='save_code', value=param)
                         op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
                         op.addParameter(name='colormap', value=PARAM[param]['colormap'])
                         desc = {
                                 'Data': {
                                     PARAM[param]['name']: PARAM[param]['label'],
                                     'utctime': 'time'
                                 },
                                  'Metadata': {
                                     'heightList': 'range',
                                     'data_azi': 'azimuth',
                                     'data_ele': 'elevation',
                                 }
                             }
                         if args.save:
                             opObj10 = merge.addOperation(name='HDFWriter')
                             opObj10.addParameter(name='path',value=path_save, format='str')
                             opObj10.addParameter(name='Reset',value=True)
                             opObj10.addParameter(name='setType',value='weather')
                             opObj10.addParameter(name='description',value='desc')
                             opObj10.addParameter(name='blocksPerFile',value='1',format='int')
                             opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
                             opObj10.addParameter(name='dataList',value='{},utctime'.format(PARAM[param]['name']))
                 project.start()
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
                 parser.add_argument('experiment',
                                     help='Experiment name')
                 parser.add_argument('--parameters', nargs='*', default=['P'],
                                     help='Variables to process: P, Z, V')
                 parser.add_argument('--time_offset', default=0,
                                     help='Fix time offset')
                 parser.add_argument('--range', default=0, type=float,
                                     help='Max range to plot')
                 parser.add_argument('--save', action='store_true',
                                     help='Create output files')
                 parser.add_argument('--show', action='store_true',
                                     help='Show matplotlib plot.')
                 parser.add_argument('--online', action='store_true',
                                     help='Set online mode.')
                 args = parser.parse_args()
                 main(args)

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