schain Commit - r1367:42e9a23049f5 · Jicamarca Repository

19 DE AGOSTO 2021 RM

avaldez -

r1367:42e9a23049f5

parent child

Context file:

r1367:42e9a23049f5

Expand all files

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

schainpy/scripts/HDF5_WR_DATA.py created 644 +31 0

@@ -0,0 +1,31
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	path='/DATA_RM/TEST_HDF5'
	6	path_adq=path
	7	path_ped='/DATA_RM/TEST_PEDESTAL/P2021200'
	8	figpath = '/home/soporte/Pictures'
	9	desc = "Simulator Test"
	10
	11	controllerObj = Project()
	12	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	13	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	14	path=path,
	15	startDate="2021/01/01", #"2020/01/01",#today,
	16	endDate= "2021/12/01", #"2020/12/30",#today,
	17	startTime='00:00:00',
	18	endTime='23:59:59',
	19	t_Interval_p=0.01,
	20	n_Muestras_p=100,
	21	delay=5,
	22	#set=0,
	23	online=0,
	24	walk=1)#1
	25
	26	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	27
	28
	29	controllerObj.start()
	30	#online 1 utc_adq 1617490240.48
	31	#online 0 utc_adq 1617489815.4804

schainpy/scripts/PEDESTAL_CLIENT_F.py created 644 +92 0

@@ -0,0 +1,92
	1	import numpy
	2	import sys
	3	import zmq
	4	import time
	5	import h5py
	6	import os
	7
	8	timetuple=time.localtime()
	9	meta='P'
	10	dir="%s%4.4d%3.3d"%(meta,timetuple.tm_year,timetuple.tm_yday)
	11
	12	path="/home/soporte/Downloads/PEDESTAL/"+dir
	13
	14	ext=".hdf5"
	15
	16	port ="5556"
	17	if len(sys.argv)>1:
	18	port = sys.argv[1]
	19	int(port)
	20
	21	if len(sys.argv)>2:
	22	port1 = sys.argv[2]
	23	int(port1)
	24
	25	#Socket to talk to server
	26	context = zmq.Context()
	27	socket = context.socket(zmq.SUB)
	28
	29	print("Collecting updates from weather server...")
	30	socket.connect("tcp://localhost:%s"%port)
	31
	32	if len(sys.argv)>2:
	33	socket.connect("tcp://localhost:%s"%port1)
	34
	35	#Subscribe to zipcode, default is NYC,10001
	36	topicfilter = "10001"
	37	socket.setsockopt_string(zmq.SUBSCRIBE,topicfilter)
	38	#Process 5 updates
	39	total_value=0
	40	count= -1
	41	azi= []
	42	elev=[]
	43	time0=[]
	44	#for update_nbr in range(250):
	45	while(True):
	46	string= socket.recv()
	47	topic,ang_elev,ang_elev_dec,ang_azi,ang_azi_dec,seconds,seconds_dec= string.split()
	48	ang_azi =float(ang_azi)+1e-3*float(ang_azi_dec)
	49	ang_elev =float(ang_elev)+1e-3*float(ang_elev_dec)
	50	seconds =float(seconds) +1e-6*float(seconds_dec)
	51	azi.append(ang_azi)
	52	elev.append(ang_elev)
	53	time0.append(seconds)
	54	count +=1
	55	if count == 100:
	56	timetuple=time.localtime()
	57	epoc = time.mktime(timetuple)
	58	#print(epoc)
	59	fullpath = path + ("/" if path[-1]!="/" else "")
	60
	61	if not os.path.exists(fullpath):
	62	os.mkdir(fullpath)
	63
	64	azi_array = numpy.array(azi)
	65	elev_array = numpy.array(elev)
	66	time0_array= numpy.array(time0)
	67	pedestal_array=numpy.array([azi,elev,time0])
	68	count=0
	69	azi= []
	70	elev=[]
	71	time0=[]
	72	#print(pedestal_array[0])
	73	#print(pedestal_array[1])
	74
	75	meta='PE'
	76	filex="%s%4.4d%3.3d%10.4d%s"%(meta,timetuple.tm_year,timetuple.tm_yday,epoc,ext)
	77	filename = os.path.join(fullpath,filex)
	78	fp = h5py.File(filename,'w')
	79	#print("Escribiendo HDF5...",epoc)
	80	#·················· Data·....······································
	81	grp = fp.create_group("Data")
	82	dset = grp.create_dataset("azimuth" , data=pedestal_array[0])
	83	dset = grp.create_dataset("elevacion", data=pedestal_array[1])
	84	dset = grp.create_dataset("utc" , data=pedestal_array[2])
	85	#·················· Metadata·······································
	86	grp = fp.create_group("Metadata")
	87	dset = grp.create_dataset("utctimeInit", data=pedestal_array[2][0])
	88	timeInterval = pedestal_array[2][1]-pedestal_array[2][0]
	89	dset = grp.create_dataset("timeInterval", data=timeInterval)
	90	fp.close()
	91
	92	#print ("Average messagedata value for topic '%s' was %dF" % ( topicfilter,total_value / update_nbr))

schainpy/scripts/PEDESTAL_SERVER_F.py created 644 +48 0

@@ -0,0 +1,48
	1	###########################################################################
	2	############################### SERVIDOR###################################
	3	######################### SIMULADOR DE PEDESTAL############################
	4	###########################################################################
	5	import time
	6	import math
	7	import numpy
	8	import struct
	9	from time import sleep
	10	import zmq
	11	import pickle
	12	port="5556"
	13	context = zmq.Context()
	14	socket = context.socket(zmq.PUB)
	15	socket.bind("tcp://*:%s"%port)
	16	###### PARAMETROS DE ENTRADA################################
	17	print("PEDESTAL RESOLUCION 0.01")
	18	print("MAXIMA VELOCIDAD DEL PEDESTAL")
	19	ang_elev = 4.12
	20	ang_azi = 30
	21	velocidad= input ("Ingresa velocidad:")
	22	velocidad= float(velocidad)
	23	print (velocidad)
	24	############################################################
	25	sleep(3)
	26	print("Start program")
	27	t1 = time.time()
	28	count=0
	29	while(True):
	30	tmp_vuelta = int(360/velocidad)
	31	t1=t1+tmp_vuelta*count
	32	count= count+1
	33	muestras_seg = 100
	34	t2 = time.time()
	35	for i in range(tmp_vuelta):
	36	for j in range(muestras_seg):
	37	tmp_variable = (i+j/100.0)
	38	ang_azi = (tmp_variable)*float(velocidad)
	39	seconds = t1+ tmp_variable
	40	topic=10001
	41	print ("Azim°: ","%.4f"%ang_azi,"Time:" ,"%.5f"%seconds)
	42	seconds_dec=(seconds-int(seconds))*1e6
	43	ang_azi_dec= (ang_azi-int(ang_azi))*1e3
	44	ang_elev_dec=(ang_elev-int(ang_elev))*1e3
	45	sleep(0.0088)
	46	socket.send_string("%d %d %d %d %d %d %d"%(topic,ang_elev,ang_elev_dec,ang_azi,ang_azi_dec,seconds,seconds_dec))
	47	t3 = time.time()
	48	print ("Total time for 1 vuelta in Seconds",t3-t2)

schainpy/scripts/TEST_USRP_OPERACIONES.py created 644 +275 0

@@ -0,0 +1,275
	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	figpath = '/home/soporte/Pictures/TEST_RP_0001'
	31	figpath = '/home/soporte/Pictures/TEST_RP_6000'
	32	figpath = '/home/soporte/Pictures/USRP'
	33	#remotefolder = "/home/wmaster/graficos"
	34	#######################################################################
	35	################# RANGO DE PLOTEO######################################
	36	#######################################################################
	37	dBmin = '-5'
	38	dBmax = '20'
	39	xmin = '0'
	40	xmax ='24'
	41	ymin = '0'
	42	ymax = '600'
	43	#######################################################################
	44	########################FECHA##########################################
	45	#######################################################################
	46	str = datetime.date.today()
	47	today = str.strftime("%Y/%m/%d")
	48	str2 = str - datetime.timedelta(days=1)
	49	yesterday = str2.strftime("%Y/%m/%d")
	50	#######################################################################
	51	######################## UNIDAD DE LECTURA#############################
	52	#######################################################################
	53	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	54	path=path,
	55	startDate="2021/07/02",#today,
	56	endDate="2021/07/02",#today,
	57	startTime='14:50:00',# inicio libre
	58	#startTime='00:00:00',
	59	endTime='14:55:59',
	60	delay=0,
	61	#set=0,
	62	online=0,
	63	walk=1,
	64	ippKm = 6000)
	65
	66	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	67	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	68	#######################################################################
	69	################ OPERACIONES DOMINIO DEL TIEMPO########################
	70	#######################################################################
	71
	72	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	73
	74	opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
	75	opObj11.addParameter(name='minIndex', value='1', format='int')
	76	# opObj11.addParameter(name='maxIndex', value='10000', format='int')
	77	opObj11.addParameter(name='maxIndex', value='39980', format='int')
	78
	79	#
	80	# 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,'+\
	81	# '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'
	82
	83	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	84	#opObj11.addParameter(name='frequency', value='49920000')
	85
	86	'''
	87	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	88	opObj11.addParameter(name='n', value='625', format='int')#10
	89	opObj11.addParameter(name='removeDC', value=1, format='int')
	90	'''
	91
	92	# Ploteo TEST
	93	'''
	94	opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
	95	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	96	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	97	#opObj11.addParameter(name='xmax', value=8)
	98	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
	99	'''
	100	# OJO SCOPE
	101	#opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	102	#opObj10.addParameter(name='id', value='10', format='int')
	103	##opObj10.addParameter(name='xmin', value='0', format='int')
	104	##opObj10.addParameter(name='xmax', value='50', format='int')
	105	#opObj10.addParameter(name='type', value='iq')
	106	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	107	##opObj10.addParameter(name='ymax', value='8500', format='int')
	108	#opObj11.addParameter(name='save', value=figpath, format='str')
	109	#opObj11.addParameter(name='save_period', value=10, format='int')
	110
	111	#opObj10 = procUnitConfObjA.addOperation(name='setH0')
	112	#opObj10.addParameter(name='h0', value='-5000', format='float')
	113
	114	#opObj11 = procUnitConfObjA.addOperation(name='filterByHeights')
	115	#opObj11.addParameter(name='window', value='1', format='int')
	116
	117	#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'
	118	#opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
	119	#opObj11.addParameter(name='code', value=codigo, format='floatlist')
	120	#opObj11.addParameter(name='nCode', value='1', format='int')
	121	#opObj11.addParameter(name='nBaud', value='28', format='int')
	122
	123	#opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	124	#opObj11.addParameter(name='n', value='100', format='int')
	125
	126	#######################################################################
	127	########## OPERACIONES ParametersProc########################
	128	#######################################################################
	129	###procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	130	'''
	131
	132	opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
	133	opObj11.addParameter(name='path_ped', value=path_ped)
	134	opObj11.addParameter(name='path_adq', value=path_adq)
	135	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	136	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	137	opObj11.addParameter(name='blocksPerfile', value='100', format='int')
	138	opObj11.addParameter(name='f_a_p', value='25', format='int')
	139	opObj11.addParameter(name='online', value='0', format='int')
	140
	141	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	142	opObj11.addParameter(name='n', value='40', format='int')
	143
	144	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	145	opObj11.addParameter(name='save', value=figpath)
	146	opObj11.addParameter(name='save_period', value=1)
	147
	148	8
	149	'''
	150
	151	#######################################################################
	152	########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
	153	#######################################################################
	154
	155	#procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	156	#procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int')
	157	#procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int')
	158
	159	procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
	160	#procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int')
	161	#procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int')
	162	opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
	163	#opObj11.addParameter(name='timeInterval', value='4', format='int')
	164	opObj11.addParameter(name='n', value='100', format='int')
	165
	166	#procUnitConfObjB.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList')
	167
	168	#opObj13 = procUnitConfObjB.addOperation(name='removeDC')
	169	#opObj13.addParameter(name='mode', value='2', format='int')
	170
	171	#opObj11 = procUnitConfObjB.addOperation(name='IncohInt', optype='other')
	172	#opObj11.addParameter(name='n', value='8', format='float')
	173	#######################################################################
	174	########## PLOTEO DOMINIO DE LA FRECUENCIA#############################
	175	#######################################################################
	176	#----
	177
	178	opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
	179	opObj11.addParameter(name='id', value='10', format='int')
	180	opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
	181	#opObj11.addParameter(name='xmin', value=-100000, format='float')
	182	#opObj11.addParameter(name='xmax', value=100000, format='float')
	183	opObj11.addParameter(name='oneFigure', value=False,format='bool')
	184	#opObj11.addParameter(name='zmin', value=-10, format='int')
	185	#opObj11.addParameter(name='zmax', value=40, format='int')
	186	opObj11.addParameter(name='ymin', value=10, format='int')
	187	opObj11.addParameter(name='ymax', value=55, format='int')
	188	opObj11.addParameter(name='grid', value=True, format='bool')
	189	#opObj11.addParameter(name='showprofile', value='1', format='int')
	190	opObj11.addParameter(name='save', value=figpath, format='str')
	191	#opObj11.addParameter(name='save_period', value=10, format='int')
	192
	193	'''
	194	opObj11 = procUnitConfObjC.addOperation(name='RTIHeisPlot')
	195	opObj11.addParameter(name='id', value='10', format='int')
	196	opObj11.addParameter(name='wintitle', value='RTI_Alturas', format='str')
	197	opObj11.addParameter(name='xmin', value=11.0, format='float')
	198	opObj11.addParameter(name='xmax', value=18.0, format='float')
	199	opObj11.addParameter(name='zmin', value=10, format='int')
	200	opObj11.addParameter(name='zmax', value=30, format='int')
	201	opObj11.addParameter(name='ymin', value=5, format='int')
	202	opObj11.addParameter(name='ymax', value=28, format='int')
	203	opObj11.addParameter(name='showprofile', value='1', format='int')
	204	opObj11.addParameter(name='save', value=figpath, format='str')
	205	opObj11.addParameter(name='save_period', value=10, format='int')
	206	'''
	207	'''
	208	#SpectraPlot
	209
	210	opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
	211	opObj11.addParameter(name='id', value='1', format='int')
	212	opObj11.addParameter(name='wintitle', value='Spectra', format='str')
	213	#opObj11.addParameter(name='xmin', value=-0.01, format='float')
	214	#opObj11.addParameter(name='xmax', value=0.01, format='float')
	215	opObj11.addParameter(name='zmin', value=dBmin, format='int')
	216	opObj11.addParameter(name='zmax', value=dBmax, format='int')
	217	#opObj11.addParameter(name='ymin', value=ymin, format='int')
	218	#opObj11.addParameter(name='ymax', value=ymax, format='int')
	219	opObj11.addParameter(name='showprofile', value='1', format='int')
	220	opObj11.addParameter(name='save', value=figpath, format='str')
	221	opObj11.addParameter(name='save_period', value=10, format='int')
	222
	223	#RTIPLOT
	224
	225	opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external')
	226	opObj11.addParameter(name='id', value='2', format='int')
	227	opObj11.addParameter(name='wintitle', value='RTIPlot', format='str')
	228	opObj11.addParameter(name='zmin', value=dBmin, format='int')
	229	opObj11.addParameter(name='zmax', value=dBmax, format='int')
	230	#opObj11.addParameter(name='ymin', value=ymin, format='int')
	231	#opObj11.addParameter(name='ymax', value=ymax, format='int')
	232	#opObj11.addParameter(name='xmin', value=15, format='int')
	233	#opObj11.addParameter(name='xmax', value=16, format='int')
	234
	235	opObj11.addParameter(name='showprofile', value='1', format='int')
	236	opObj11.addParameter(name='save', value=figpath, format='str')
	237	opObj11.addParameter(name='save_period', value=10, format='int')
	238
	239	'''
	240	# opObj11 = procUnitConfObjB.addOperation(name='CrossSpectraPlot', optype='other')
	241	# opObj11.addParameter(name='id', value='3', format='int')
	242	# opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
	243	# opObj11.addParameter(name='ymin', value=ymin, format='int')
	244	# opObj11.addParameter(name='ymax', value=ymax, format='int')
	245	# opObj11.addParameter(name='phase_cmap', value='jet', format='str')
	246	# opObj11.addParameter(name='zmin', value=dBmin, format='int')
	247	# opObj11.addParameter(name='zmax', value=dBmax, format='int')
	248	# opObj11.addParameter(name='figpath', value=figures_path, format='str')
	249	# opObj11.addParameter(name='save', value=0, format='bool')
	250	# opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
	251	# #
	252	# opObj11 = procUnitConfObjB.addOperation(name='CoherenceMap', optype='other')
	253	# opObj11.addParameter(name='id', value='4', format='int')
	254	# opObj11.addParameter(name='wintitle', value='Coherence', format='str')
	255	# opObj11.addParameter(name='phase_cmap', value='jet', format='str')
	256	# opObj11.addParameter(name='xmin', value=xmin, format='float')
	257	# opObj11.addParameter(name='xmax', value=xmax, format='float')
	258	# opObj11.addParameter(name='figpath', value=figures_path, format='str')
	259	# opObj11.addParameter(name='save', value=0, format='bool')
	260	# opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
	261	#
	262
	263	'''
	264	#######################################################################
	265	############### UNIDAD DE ESCRITURA ###################################
	266	#######################################################################
	267	#opObj11 = procUnitConfObjB.addOperation(name='SpectraWriter', optype='other')
	268	#opObj11.addParameter(name='path', value=wr_path)
	269	#opObj11.addParameter(name='blocksPerFile', value='50', format='int')
	270	print ("Escribiendo el archivo XML")
	271	print ("Leyendo el archivo XML")
	272	'''
	273
	274
	275	controllerObj.start()

schainpy/scripts/USRP_ADQ_PP.py created 644 +126 0

@@ -0,0 +1,126
	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/TEST_ONLINE'
	28	path_pp = '/DATA_RM/TEST_HDF5'
	29
	30	figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
	31	#remotefolder = "/home/wmaster/graficos"
	32	#######################################################################
	33	################# RANGO DE PLOTEO######################################
	34	#######################################################################
	35	dBmin = '-5'
	36	dBmax = '20'
	37	xmin = '0'
	38	xmax ='24'
	39	ymin = '0'
	40	ymax = '600'
	41	#######################################################################
	42	########################FECHA##########################################
	43	#######################################################################
	44	str = datetime.date.today()
	45	today = str.strftime("%Y/%m/%d")
	46	str2 = str - datetime.timedelta(days=1)
	47	yesterday = str2.strftime("%Y/%m/%d")
	48	#######################################################################
	49	######################## UNIDAD DE LECTURA#############################
	50	#######################################################################
	51	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	52	path=path,
	53	startDate="2021/01/01",#today,
	54	endDate="2021/12/30",#today,
	55	startTime='00:00:00',
	56	endTime='23:59:59',
	57	delay=0,
	58	#set=0,
	59	online=1,
	60	walk=1,
	61	ippKm = 60)
	62
	63	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	64	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	65	#######################################################################
	66	################ OPERACIONES DOMINIO DEL TIEMPO########################
	67	#######################################################################
	68
	69	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	70
	71	#
	72	# 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,'+\
	73	# '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'
	74
	75	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	76	#opObj11.addParameter(name='frequency', value='70312500')
	77	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	78	opObj11.addParameter(name='n', value='625', format='int')#10
	79	opObj11.addParameter(name='removeDC', value=1, format='int')
	80	# Ploteo TEST
	81	'''
	82	opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
	83	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	84	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	85	#opObj11.addParameter(name='xmax', value=8)
	86	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
	87	'''
	88	# OJO SCOPE
	89	#opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	90	#opObj10.addParameter(name='id', value='10', format='int')
	91	##opObj10.addParameter(name='xmin', value='0', format='int')
	92	##opObj10.addParameter(name='xmax', value='50', format='int')
	93	#opObj10.addParameter(name='type', value='iq')
	94	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	95	##opObj10.addParameter(name='ymax', value='8500', format='int')
	96	#opObj11.addParameter(name='save', value=figpath, format='str')
	97	#opObj11.addParameter(name='save_period', value=10, format='int')
	98
	99	#opObj10 = procUnitConfObjA.addOperation(name='setH0')
	100	#opObj10.addParameter(name='h0', value='-5000', format='float')
	101
	102	#opObj11 = procUnitConfObjA.addOperation(name='filterByHeights')
	103	#opObj11.addParameter(name='window', value='1', format='int')
	104
	105	#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'
	106	#opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
	107	#opObj11.addParameter(name='code', value=codigo, formatyesterday='floatlist')
	108	#opObj11.addParameter(name='nCode', value='1', format='int')
	109	#opObj11.addParameter(name='nBaud', value='28', format='int')
	110
	111	#opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	112	#opObj11.addParameter(name='n', value='100', format='int')
	113
	114	#######################################################################
	115	########## OPERACIONES ParametersProc########################
	116	#######################################################################
	117
	118	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	119	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	120	opObj10.addParameter(name='path',value=path_pp)
	121	#opObj10.addParameter(name='mode',value=0)
	122	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	123	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	124	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	125
	126	controllerObj.start()

schainpy/scripts/USRP_ADQ_SPECM.py created 644 +126 0

@@ -0,0 +1,126
	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/TEST_ONLINE'
	28	path_pp = '/DATA_RM/TEST_HDF5'
	29
	30	figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
	31	#remotefolder = "/home/wmaster/graficos"
	32	#######################################################################
	33	################# RANGO DE PLOTEO######################################
	34	#######################################################################
	35	dBmin = '-5'
	36	dBmax = '20'
	37	xmin = '0'
	38	xmax ='24'
	39	ymin = '0'
	40	ymax = '600'
	41	#######################################################################
	42	########################FECHA##########################################
	43	#######################################################################
	44	str = datetime.date.today()
	45	today = str.strftime("%Y/%m/%d")
	46	str2 = str - datetime.timedelta(days=1)
	47	yesterday = str2.strftime("%Y/%m/%d")
	48	#######################################################################
	49	######################## UNIDAD DE LECTURA#############################
	50	#######################################################################
	51	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	52	path=path,
	53	startDate="2021/01/01",#today,
	54	endDate="2021/12/30",#today,
	55	startTime='00:00:00',
	56	endTime='23:59:59',
	57	delay=0,
	58	#set=0,
	59	online=1,
	60	walk=1,
	61	ippKm = 60)
	62
	63	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	64	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	65	#######################################################################
	66	################ OPERACIONES DOMINIO DEL TIEMPO########################
	67	#######################################################################
	68
	69	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	70
	71	#
	72	# 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,'+\
	73	# '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'
	74
	75	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	76	#opObj11.addParameter(name='frequency', value='70312500')
	77	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	78	opObj11.addParameter(name='n', value='625', format='int')#10
	79	opObj11.addParameter(name='removeDC', value=1, format='int')
	80	# Ploteo TEST
	81	'''
	82	opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
	83	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	84	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	85	#opObj11.addParameter(name='xmax', value=8)
	86	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
	87	'''
	88	# OJO SCOPE
	89	#opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	90	#opObj10.addParameter(name='buffer_sizeid', value='10', format='int')
	91	##opObj10.addParameter(name='xmin', value='0', format='int')
	92	##opObj10.addParameter(name='xmax', value='50', format='int')
	93	#opObj10.addParameter(name='type', value='iq')
	94	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	95	##opObj10.addParameter(name='ymax', value='8500', format='int')
	96	#opObj11.addParameter(name='save', value=figpath, format='str')
	97	#opObj11.addParameter(name='save_period', value=10, format='int')
	98
	99	#opObj10 = procUnitConfObjA.addOperation(name='setH0')
	100	#opObj10.addParameter(name='h0', value='-5000', format='float')
	101
	102	#opObj11 = procUnitConfObjA.addOperation(name='filterByHeights')
	103	#opObj11.addParameter(name='window', value='1', format='int')
	104
	105	#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'
	106	#opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
	107	#opObj11.addParameter(name='code', value=codigo, formatyesterday='floatlist')
	108	#opObj11.addParameter(name='nCode', value='1', format='int')
	109	#opObj11.addParameter(name='nBaud', value='28', format='int')
	110
	111	#opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	112	#opObj11.addParameter(name='n', value='100', format='int')
	113
	114	#######################################################################
	115	########## OPERACIONES ParametersProc########################
	116	#######################################################################
	117
	118	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	119	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	120	opObj10.addParameter(name='path',value=path_pp)
	121	#opObj10.addParameter(name='mode',value=0)
	122	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	123	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	124	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	125
	126	controllerObj.start()

schainpy/scripts/WR_PROC_PP_PLOT.py created 644 +52 0

@@ -0,0 +1,52
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	#path='/DATA_RM/TEST_HDF5/d2021200'
	6	#path='/DATA_RM/TEST_HDF5/d2021200'
	7	path='/DATA_RM/TEST_HDF5/d2021203'
	8
	9	path_adq=path
	10	#path_ped='/DATA_RM/TEST_PEDESTAL/P2021200'
	11	path_ped='/DATA_RM/TEST_PEDESTAL/P2021203'
	12
	13	figpath = '/home/soporte/Pictures'
	14	desc = "Simulator Test"
	15
	16	controllerObj = Project()
	17	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	18	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	19	path=path,
	20	startDate="2021/01/01", #"2020/01/01",#today,
	21	endDate= "2021/12/01", #"2020/12/30",#today,
	22	startTime='00:00:00',
	23	endTime='23:59:59',
	24	t_Interval_p=0.01,
	25	n_Muestras_p=100,
	26	delay=5,
	27	#set=0,
	28	online=0,
	29	walk=0)#1
	30
	31	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	32
	33	opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
	34	opObj11.addParameter(name='path_ped', value=path_ped)
	35	opObj11.addParameter(name='path_adq', value=path_adq)
	36	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	37	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	38	opObj11.addParameter(name='blocksPerfile', value='100', format='int')
	39	opObj11.addParameter(name='f_a_p', value='25', format='int')
	40	opObj11.addParameter(name='online', value='0', format='int')
	41
	42
	43	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	44	opObj11.addParameter(name='n', value='40', format='int')
	45
	46	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	47	opObj11.addParameter(name='save', value=figpath)
	48	opObj11.addParameter(name='save_period', value=1)
	49
	50	controllerObj.start()
	51	#online 1 utc_adq 1617490240.48
	52	#online 0 utc_adq 1617489815.4804

schainpy/scripts/WR_PROC_PP_PLOT_ONLINE.py created 644 +59 0

@@ -0,0 +1,59
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	#path='/DATA_RM/TEST_HDF5/d2021200'
	6	#path='/DATA_RM/TEST_HDF5/d2021200'
	7	#path='/DATA_RM/TEST_HDF5/d2021214'
	8	#path='/DATA_RM/TEST_HDF5/d2021229'
	9
	10	path='/DATA_RM/TEST_HDF5/d2021231'
	11
	12
	13	path_adq=path
	14	#path_ped='/DATA_RM/TEST_PEDESTAL/P2021200'
	15	#path_ped='/DATA_RM/TEST_PEDESTAL/P2021214'
	16	#path_ped='/DATA_RM/TEST_PEDESTAL/P2021230'
	17	path_ped='/DATA_RM/TEST_PEDESTAL/P20210819'
	18	figpath = '/home/soporte/Pictures'
	19	desc = "Simulator Test"
	20
	21	controllerObj = Project()
	22	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	23	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	24	path=path,
	25	startDate="2021/01/01", #"2020/01/01",#today,
	26	endDate= "2021/12/01", #"2020/12/30",#today,
	27	startTime='00:00:00',
	28	endTime='23:59:59',
	29	t_Interval_p=0.01,
	30	n_Muestras_p=100,
	31	delay=30,
	32	#set=0,
	33	online=1,
	34	walk=0,
	35	nTries=6)#1
	36
	37	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	38
	39	opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
	40	opObj11.addParameter(name='path_ped', value=path_ped)
	41	opObj11.addParameter(name='path_adq', value=path_adq)
	42	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	43	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	44	opObj11.addParameter(name='blocksPerfile', value='100', format='int')
	45	opObj11.addParameter(name='f_a_p', value='25', format='int')
	46	opObj11.addParameter(name='online', value='1', format='int')# habilitar el enable aqui tambien
	47
	48
	49	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	50	opObj11.addParameter(name='n', value='40', format='int')
	51	# este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
	52
	53	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	54	opObj11.addParameter(name='save', value=figpath)
	55	opObj11.addParameter(name='save_period', value=1)
	56
	57	controllerObj.start()
	58	#online 1 utc_adq 1617490240.48
	59	#online 0 utc_adq 1617489815.4804

schainpy/scripts/config_WR.txt created 644 +35 0

@@ -0,0 +1,35
	1	#*******************************************************************************
	2	#***********ARCHIVO DE CONFIGURACION - RADAR METEOROLOGICO******************
	3	#*******************************************************************************
	4	# 1-Resolucion_angular(Grados º)-F
	5	1.0
	6	# 2-Velocidad_Pedestal Azimuth(º/s)-F
	7	4.0
	8	# 3-Posicion_Pedestal Azimuth(º/s)-F
	9	0.0
	10	# 4-Posicion_Pedestal Elevacion(º/s)-F
	11	30.0
	12	# 5-IPP(useg)-F
	13	400
	14	# n-PulsePair-nFFTPoints-R
	15	625
	16	# 6-Cantidad_Muestras_archivo_pedestal-F
	17	100
	18	# 7-Tiempo_por_muestra_pedestal-F
	19	0.01
	20	# Tiempo_archivo_por_pedestal-R
	21	1.0
	22	# 8-Bloques_por_arhivo_adquisicion-F
	23	100.0
	24	# tiempo_por_archivo_adquisicion-R
	25	25.0
	26	# mode Time Domain(T , 1) or Frequency Domain(F , 0)
	27	1
	28	# path_p
	29	/home/developer/Downloads/Pedestal/P2021093
	30	# path_a
	31	/home/developer/Downloads/HDF5_TESTPP2V3/d2021093
	32	# online
	33	0
	34	# Directorio final
	35	/home/developer/Downloads/HDF5_WR/

schainpy/scripts/readFileconfig.py created 644 +70 0

@@ -0,0 +1,70
	1	print("LECTURA DE ARCHIVOS DE CONFIGURACION")
	2	class ReadfileWR():
	3	def __init__(self,filename):
	4	f = open(filename, "r")
	5	i=0
	6	self.dict={'paht_ped':None,'path_adq':None,'path_res':None,'resolution':None,'vel_ped_azi':None,'pos_ped_azi':None,'pos_ped_ele':None,'ipp':None,'n':None,'len_ped':None,\
	7	't_s_ped':None,'t_f_ped':None,'b_f_adq':None,'t_f_adq':None,'mode':None,'online':None}
	8	while(True):
	9	##print(i)
	10	linea = f.readline()
	11	if i==4:
	12	resolution=float(linea)
	13	self.dict['resolution']=resolution
	14	if i==6:
	15	vel_pedestal_a=float(linea)
	16	self.dict['vel_ped_azi']=vel_pedestal_a
	17	if i==8:
	18	pos_pedestal_a=float(linea)
	19	self.dict['pos_ped_azi']=pos_pedestal_a
	20	if i==10:
	21	pos_pedestal_e=float(linea)
	22	self.dict['pos_ped_ele']=pos_pedestal_e
	23	if i==12:
	24	ipp = float(linea)
	25	self.dict['ipp']= round(ipp,5)
	26	if i==14:
	27	n = float(linea)
	28	self.dict['n']= n
	29	if i==16:
	30	len_pedestal= float(linea)
	31	self.dict['len_ped']= len_pedestal
	32	if i==18:
	33	time_x_sample_ped=float(linea)
	34	self.dict['t_s_ped']= time_x_sample_ped
	35	if i==20:
	36	time_x_file_ped = float(linea)
	37	self.dict['t_f_ped']= time_x_file_ped
	38	if i==22:
	39	bloques_x_file_adq= float(linea)
	40	self.dict['b_f_adq']=bloques_x_file_adq
	41	if i==24:
	42	time_x_file_adq = float(linea)
	43	self.dict['t_f_adq'] = time_x_file_adq
	44	if i==26:
	45	mode= int(linea)
	46	self.dict['mode'] = mode
	47	if i==28:
	48	path_p= str(linea)
	49	self.dict['path_ped'] = path_p
	50	if i==30:
	51	path_a= str(linea)
	52	self.dict['path_adq'] = path_a
	53	if i==32:
	54	online= int(linea)
	55	self.dict['online'] = online
	56	if i==34:
	57	path_r= str(linea)
	58	self.dict['path_res'] = path_r
	59	#print(linea)
	60	if not linea:
	61	break
	62	i+=1
	63	f.close()
	64	def getDict(self):
	65	return self.dict
	66
	67
	68	#filename= "/home/developer/Downloads/config_WR.txt"
	69	#dict= ReadfileWR(filename).getDict()
	70	#print(dict)

schainpy/scripts/sun_high_ivan.py created 644 +118 0

@@ -0,0 +1,118
	1	#!python
	2	'''
	3	'''
	4
	5	import os, sys
	6	import datetime
	7	import time
	8
	9
	10	from schainpy.controller import Project
	11
	12	desc = "USRP_test"
	13	filename = "USRP_processing.xml"
	14	controllerObj = Project()
	15	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	16
	17	############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
	18
	19	#######################################################################
	20	######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
	21	#######################################################################
	22	# path IVAN
	23	path = '/home/soporte/jarsjuliahigh/high'
	24
	25	figpath = '/home/soporte/Pictures/IVAN'
	26	#remotefolder = "/home/wmaster/graficos"
	27	#######################################################################
	28	################# RANGO DE PLOTEO######################################
	29	#######################################################################
	30	dBmin = '10'
	31	dBmax = '55'
	32	xmin = '0'
	33	xmax ='24'
	34	ymin = '0'
	35	ymax = '600'
	36	#######################################################################
	37	########################FECHA##########################################
	38	#######################################################################
	39	str = datetime.date.today()
	40	today = str.strftime("%Y/%m/%d")
	41	str2 = str - datetime.timedelta(days=1)
	42	yesterday = str2.strftime("%Y/%m/%d")
	43	#######################################################################
	44	######################## UNIDAD DE LECTURA#############################
	45	#######################################################################
	46	readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
	47	path=path,
	48	startDate="2021/07/02",#today,
	49	endDate="2021/07/02",#today,
	50	startTime='14:50:01',# inicio libre
	51	endTime='14:55:59',
	52	delay=0,
	53	#set=0,
	54	online=0,
	55	walk=0)
	56
	57	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	58	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	59	#######################################################################
	60	################ OPERACIONES DOMINIO DEL TIEMPO########################
	61	#######################################################################
	62
	63	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	64
	65	#opObj10 = procUnitConfObjA.addOperation(name='selectChannels')
	66	#opObj10.addParameter(name='channelList', value=[0])
	67
	68	'''
	69	opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	70	opObj10.addParameter(name='id', value='10', format='int')
	71	#opObj10.addParameter(name='xmin', value='0', format='int')
	72	##opObj10.addParameter(name='xmax', value='50', format='int')
	73	opObj10.addParameter(name='type', value='iq')
	74	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	75	##opObj10.addParameter(name='ymax', value='8500', format='int')
	76	#opObj11.addParameter(name='save', value=figpath, format='str')
	77	#opObj11.addParameter(name='save_period', value=10, format='int')
	78	'''
	79	###opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
	80	###opObj11.addParameter(name='minIndex', value='1', format='int')
	81	#### opObj11.addParameter(name='maxIndex', value='10000', format='int')
	82	####opObj11.addParameter(name='maxIndex', value='39980', format='int')
	83
	84	#######################################################################
	85	########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
	86	#######################################################################
	87
	88	#procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	89	#procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int')
	90	#procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int')
	91
	92	procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
	93
	94	opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
	95	#opObj11.addParameter(name='timeInterval', value='4', format='int')
	96	opObj11.addParameter(name='n', value='100', format='int')
	97
	98	#opObj11.addParameter(name='overlapping', value=True, format='bool')
	99
	100	opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
	101	opObj11.addParameter(name='id', value='10', format='int')
	102	opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
	103
	104	#opObj11.addParameter(name='xmin', value=-100000, format='float')
	105	#opObj11.addParameter(name='xmax', value=100000, format='float')
	106	opObj11.addParameter(name='oneFigure', value=False,format='bool')
	107	#opObj11.addParameter(name='zmin', value=-10, format='int')
	108	#opObj11.addParameter(name='zmax', value=40, format='int')
	109	opObj11.addParameter(name='ymin', value=dBmin, format='int')
	110	opObj11.addParameter(name='ymax', value=dBmax, format='int')
	111	opObj11.addParameter(name='grid', value=True, format='bool')
	112	#opObj11.addParameter(name='showprofile', value='1', format='int')
	113	opObj11.addParameter(name='save', value=figpath, format='str')
	114	#opObj11.addParameter(name='save_period', value=10, format='int')
	115
	116
	117
	118	controllerObj.start()

schainpy/scripts/sun_high_jhon.py created 644 +103 0

@@ -0,0 +1,103
	1	#!python
	2	'''
	3	'''
	4
	5	import os, sys
	6	import datetime
	7	import time
	8
	9
	10	from schainpy.controller import Project
	11
	12	desc = "USRP_test"
	13	filename = "USRP_processing.xml"
	14	controllerObj = Project()
	15	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	16
	17	############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
	18
	19	#######################################################################
	20	######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
	21	#######################################################################
	22	# path JHON
	23	path = '/home/soporte/jars2'
	24
	25	figpath = '/home/soporte/Pictures/JHON'
	26	#remotefolder = "/home/wmaster/graficos"
	27	#######################################################################
	28	################# RANGO DE PLOTEO######################################
	29	#######################################################################
	30	dBmin = '0'
	31	dBmax = '50'
	32	xmin = '0'
	33	xmax ='24'
	34	ymin = '0'
	35	ymax = '600'
	36	#######################################################################
	37	########################FECHA##########################################
	38	#######################################################################
	39	str = datetime.date.today()
	40	today = str.strftime("%Y/%m/%d")
	41	str2 = str - datetime.timedelta(days=1)
	42	yesterday = str2.strftime("%Y/%m/%d")
	43	#######################################################################
	44	######################## UNIDAD DE LECTURA#############################
	45	#######################################################################
	46	readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
	47	path=path,
	48	startDate="2021/07/02",#today,
	49	endDate="2021/07/02",#today,
	50	startTime='19:45:00',# inicio libre
	51	endTime='19:50:59',
	52	delay=0,
	53	#set=0,
	54	online=0,
	55	walk=0)
	56
	57	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	58	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	59	#######################################################################
	60	################ OPERACIONES DOMINIO DEL TIEMPO########################
	61	#######################################################################
	62
	63	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	64
	65	opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
	66	opObj11.addParameter(name='minIndex', value='1', format='int')
	67	# opObj11.addParameter(name='maxIndex', value='10000', format='int')
	68	opObj11.addParameter(name='maxIndex', value='39980', format='int')
	69
	70
	71	#######################################################################
	72	########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
	73	#######################################################################
	74
	75	#procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	76	#procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int')
	77	#procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int')
	78
	79	procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
	80
	81	#opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
	82	#opObj11.addParameter(name='timeInterval', value='4', format='int')
	83	opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
	84	#opObj11.addParameter(name='timeInterval', value='4', format='int')
	85	opObj11.addParameter(name='n', value='100', format='int')
	86
	87
	88	opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
	89	opObj11.addParameter(name='id', value='10', format='int')
	90	opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
	91	#opObj11.addParameter(name='xmin', value=-100000, format='float')
	92	#opObj11.addParameter(name='xmax', value=100000, format='float')
	93	opObj11.addParameter(name='oneFigure', value=False,format='bool')
	94	#opObj11.addParameter(name='zmin', value=-10, format='int')
	95	#opObj11.addParameter(name='zmax', value=40, format='int')
	96	opObj11.addParameter(name='ymin', value=dBmin, format='int')
	97	opObj11.addParameter(name='ymax', value=dBmax, format='int')
	98	opObj11.addParameter(name='grid', value=True, format='bool')
	99	#opObj11.addParameter(name='showprofile', value='1', format='int')
	100	opObj11.addParameter(name='save', value=figpath, format='str')
	101	#opObj11.addParameter(name='save_period', value=10, format='int')
	102
	103	controllerObj.start()

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

@@ -0,0 +1,47
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	'''
	6	NOTA:
	7	Este script de prueba.
	8	- Unidad del lectura 'HDFReader'.
	9	- Unidad de procesamiento VoltageProc
	10	- Unidad de procesamiento SpectraProc
	11	- Operacion removeDC.
	12	- Unidad de procesamiento ParametersProc
	13	- Operacion SpectralMoments
	14	- Operacion SpectralMomentsPlot
	15	- Unidad de escrituda 'HDFWriter'.
	16	'''
	17	path='/home/developer/Downloads/HDF5_WR'
	18	figpath = path
	19	desc = "Simulator Test"
	20
	21	controllerObj = Project()
	22
	23	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	24
	25	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	26	path=path,
	27	startDate="2021/01/01", #"2020/01/01",#today,
	28	endDate= "2021/12/01", #"2020/12/30",#today,
	29	startTime='00:00:00',
	30	endTime='23:59:59',
	31	delay=0,
	32	#set=0,
	33	online=0,
	34	walk=0)#1
	35
	36	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	37
	38	opObj11 = procUnitConfObjA.addOperation(name='Block360')
	39	opObj11.addParameter(name='n', value='40', format='int')
	40
	41	opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
	42	opObj11.addParameter(name='save', value=figpath)
	43	opObj11.addParameter(name='save_period', value=1)
	44	#opObj11 = procUnitConfObjA.addOperation(name='PowerPlot', optype='other')#PulsepairPowerPlot
	45	#opObj11 = procUnitConfObjA.addOperation(name='PPSignalPlot', optype='other')
	46
	47	controllerObj.start()

schainpy/scripts/test_sim00011a.py created 644 +51 0

@@ -0,0 +1,51
	1	import os,sys,json
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	'''
	6	NOTA:
	7	Este script de prueba.
	8	- Unidad del lectura 'HDFReader'.
	9	- Unidad de procesamiento ParametersProc
	10	- Operacion SpectralMomentsPlot
	11
	12	'''
	13	path = '/home/soporte/Downloads/RAWDATA_PP'
	14	path='/DATA_RM/TEST_HDF5/d2021203'
	15	figpath = '/home/soporte/Downloads/IMAGE'
	16	desc = "Simulator Test"
	17	desc_data = {
	18	'Data': {
	19	'dataPP_POW': 'Data/dataPP_POW/channel00',
	20	'utctime':'Data/utctime'
	21	},
	22	'Metadata': {
	23	'heightList' :'Metadata/heightList',
	24	'flagDataAsBlock':'Metadata/flagDataAsBlock',
	25	'profileIndex':'Metadata/profileIndex'
	26	}
	27	}
	28
	29	controllerObj = Project()
	30
	31	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	32
	33	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	34	path=path,
	35	startDate="2021/01/01", #"2020/01/01",#today,
	36	endDate= "2021/12/01", #"2020/12/30",#today,
	37	startTime='00:00:00',
	38	endTime='23:59:59',
	39	delay=0,
	40	#set=0,
	41	online=0,
	42	walk=0,
	43	description= json.dumps(desc_data))#1
	44
	45	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	46
	47	#opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')#PulsepairPowerPlot
	48	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	49
	50
	51	controllerObj.start()

schainpy/scripts/test_sim00011b.py created 644 +56 0

@@ -0,0 +1,56
	1	import os,sys,json
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	'''
	6	NOTA:
	7	Este script de prueba.
	8	- Unidad del lectura 'HDFReader'.
	9	- Unidad de procesamiento ParametersProc
	10	- Operacion SpectralMomentsPlot
	11
	12	'''
	13	path = '/home/soporte/Downloads/RAWDATA'
	14	figpath = '/home/soporte/Downloads/IMAGE'
	15	desc = "Simulator Test"
	16	desc_data = {
	17	'Data': {
	18	'data_pow': 'Data/data_pow/channel00',
	19	'data_dop': 'Data/data_dop/channel00',
	20	'utctime':'Data/utctime'
	21	},
	22	'Metadata': {
	23	'heightList':'Metadata/heightList',
	24	'nIncohInt' :'Metadata/nIncohInt',
	25	'nCohInt' :'Metadata/nCohInt',
	26	'nProfiles' :'Metadata/nProfiles',
	27	'channelList' :'Metadata/channelList'
	28	}
	29	}
	30
	31	controllerObj = Project()
	32
	33	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	34
	35	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	36	path=path,
	37	startDate="2021/01/01", #"2020/01/01",#today,
	38	endDate= "2021/12/01", #"2020/12/30",#today,
	39	startTime='00:00:00',
	40	endTime='23:59:59',
	41	delay=0,
	42	#set=0,
	43	online=0,
	44	walk=1,
	45	description= json.dumps(desc_data))#1
	46
	47	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	48	'''
	49	opObj11 = procUnitConfObjA.addOperation(name='DopplerPlot',optype='external')
	50	#opObj11.addParameter(name='xmin', value=0)
	51	#opObj11.addParameter(name='xmax', value=23)
	52	opObj11.addParameter(name='save', value=figpath)
	53	opObj11.addParameter(name='showprofile', value=0)
	54	opObj11.addParameter(name='save_period', value=10)
	55	'''
	56	controllerObj.start()

schainpy/scripts/test_sim00012.py created 644 +55 0

@@ -0,0 +1,55
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5
	6	#*************************************************************************
	7	#************************LECTURA config_WR.txt************************
	8	#*************************************************************************
	9	from readFileconfig import ReadfileWR
	10	filename= "/home/soporte/schainv3/schain/schainpy/scripts/config_WR.txt"
	11	dict= ReadfileWR(filename).getDict()
	12
	13	FixRCP_IPP = dict['ipp']*0.15 #equivalencia
	14	dataBlocksPerFile= dict['b_f_adq']
	15	profilesPerBlock= int(dict['n'])
	16	pulsepair = int(dict['n'])
	17	#*************************************************************************
	18	path = '/home/soporte/Downloads/RAWDATA_PP_C'
	19	figpath = path
	20	desc = "Simulator Test"
	21	controllerObj = Project()
	22	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	23	readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
	24	frequency=9.345e9,
	25	FixRCP_IPP= FixRCP_IPP,
	26	Tau_0 = 30,
	27	AcqH0_0=0,
	28	samples=330,
	29	AcqDH_0=0.15,
	30	FixRCP_TXA=0.15,
	31	FixRCP_TXB=0.15,
	32	Fdoppler=600.0,
	33	Hdoppler=36,
	34	Adoppler=300,#300
	35	delay=0,
	36	online=0,
	37	walk=0,
	38	profilesPerBlock=profilesPerBlock,
	39	dataBlocksPerFile=dataBlocksPerFile)#,#nTotalReadFiles=2)
	40	#opObj11 = readUnitConfObj.addOperation(name='printInfo')
	41	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	42
	43	opObj11 = procUnitConfObjA.addOperation(name='PulsePair')
	44	opObj11.addParameter(name='n', value=pulsepair, format='int')#10
	45
	46	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	47
	48	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	49	opObj10.addParameter(name='path',value=figpath)
	50	#opObj10.addParameter(name='mode',value=2)
	51	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	52	opObj10.addParameter(name='metadataList',value='utctimeInit,paramInterval,heightList,profileIndex,flagDataAsBlock',format='list')
	53	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	54
	55	controllerObj.start()

schainpy/scripts/test_sim00013.py created 644 +50 0

@@ -0,0 +1,50
	1	import os,sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	path = '/home/soporte/Downloads/RAWDATA_PP_Z'
	6	figpath = path
	7	desc = "Simulator Test"
	8
	9	controllerObj = Project()
	10
	11	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	12
	13	readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
	14	frequency=9.345e9,
	15	FixRCP_IPP= 60,
	16	Tau_0 = 30,
	17	AcqH0_0=0,
	18	samples=330,
	19	AcqDH_0=0.15,
	20	FixRCP_TXA=0.15,
	21	FixRCP_TXB=0.15,
	22	Fdoppler=600.0,
	23	Hdoppler=36,
	24	Adoppler=300,#300
	25	delay=0,
	26	online=0,
	27	walk=0,
	28	profilesPerBlock=625,
	29	dataBlocksPerFile=360)#,#nTotalReadFiles=2)
	30
	31	### opObj11 = readUnitConfObj.addOperation(name='printInfo')
	32
	33	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	34
	35	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	36	opObj11.addParameter(name='n', value='625', format='int')#10
	37	opObj11.addParameter(name='removeDC', value=1, format='int')
	38
	39	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	40
	41	opObj10 = procUnitConfObjB.addOperation(name="WeatherRadar")
	42
	43	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	44	opObj10.addParameter(name='path',value=figpath)
	45	#opObj10.addParameter(name='mode',value=0)
	46	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	47	opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
	48	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,dataPP_SNR,dataPP_WIDTH,factor_Zeh,utctime')#,format='list'
	49
	50	controllerObj.start()

schainpy/model/data/jrodata.py 0 0

NO CONTENT: modified file

schainpy/model/graphics/jroplot_base.py +14 -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)
                     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.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_ylim(0, 90)
                             ax.set_yticks(numpy.arange(0, 90, 20))
                             ax.yaxis.labelpad = 40
                     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_heispectra.py +2 0

             # Copyright (c) 2012-2020 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plo Specra Heis data
             """
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt
             class SpectraHeisPlot(Plot):
                 CODE = 'spc_heis'
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.95, 'bottom': 0.08})
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Frequency [KHz]'
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc / dataOut.normFactor)
                     data['spc_heis'] = spc
                     return data, meta
                 def plot(self):
                     c = 3E8
                     deltaHeight = self.data.yrange[1] - self.data.yrange[0]
                     x = numpy.arange(-1*len(self.data.yrange)/2., len(self.data.yrange)/2.)*(c/(2*deltaHeight*len(self.data.yrange)*1000))
+                    #x = (1/1000.0)*numpy.arange(-1*len(self.data.yrange)/2., len(self.data.yrange)/2.)*(c/(2*deltaHeight*len(self.data.yrange)*1000))
                     self.y = self.data[-1]['spc_heis']
                     self.titles = []
                     for n, ax in enumerate(self.axes):
                         ychannel = self.y[n,:]
                         if ax.firsttime:
                             self.xmin = min(x) if self.xmin is None else self.xmin
                             self.xmax = max(x) if self.xmax is None else self.xmax
                             ax.plt = ax.plot(x, ychannel, lw=1, color='b')[0]
                         else:
                             ax.plt.set_data(x, ychannel)
                         self.titles.append("Channel {}: {:4.2f}dB".format(n, numpy.max(ychannel)))
             class RTIHeisPlot(Plot):
                 CODE = 'rti_heis'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['RTI']
                     self.colorbar = False
                     self.height = 4
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc / dataOut.normFactor
                     spc = 10*numpy.log10(numpy.average(spc, axis=1))
                     data['rti_heis'] = spc
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     Y = self.data['rti_heis']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5 if self.ymin == None else self.ymin
                         self.ymax = numpy.nanmax(Y) + 5 if self.ymax == None else self.ymax
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)

schainpy/model/graphics/jroplot_parameters.py +215 0

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

schainpy/model/graphics/jroplot_spectra.py +2 0

             # Copyright (c) 2012-2021 Jicamarca Radio Observatory
             # All rights reserved.
             #
             # Distributed under the terms of the BSD 3-clause license.
             """Classes to plot Spectra data
             """
             import os
             import numpy
             from schainpy.model.graphics.jroplot_base import Plot, plt, log
             class SpectraPlot(Plot):
                 '''
                 Plot for Spectra data
                 '''
                 CODE = 'spc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.height = 2.6 * self.nrows
                     self.cb_label = 'dB'
                     if self.showprofile:
                         self.width = 4 * self.ncols
                     else:
                         self.width = 3.5 * self.ncols
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.08})
                     self.ylabel = 'Range [km]'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_spc/dataOut.normFactor)
                     data['spc'] = spc
                     data['rti'] = dataOut.getPower()
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'spc_moments':
                         data['moments'] = dataOut.moments
                         # data['spc'] = 10*numpy.log10(dataOut.data_pre[0]/dataOut.normFactor)
                     if self.CODE == 'gaussian_fit':
                         # data['moments'] = dataOut.moments
                         data['gaussfit'] = dataOut.DGauFitParams
                         # data['spc'] = 10*numpy.log10(dataOut.data_pre[0]/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     if (self.CODE == 'spc_moments') | (self.CODE == 'gaussian_fit'):
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     z = data['spc']
                     for n, ax in enumerate(self.axes):
                         noise = data['noise'][n]
                         if self.CODE == 'spc_moments':
                             mean = data['moments'][n, 1]
                         if self.CODE == 'gaussian_fit':
                             # mean = data['moments'][n, 1]
                             gau0 = data['gaussfit'][n][2,:,0]
                             gau1 = data['gaussfit'][n][2,:,1]
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.zmin = self.zmin if self.zmin else numpy.nanmin(z)
                             self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plt_profile = self.pf_axes[n].plot(
                                     data['rti'][n], y)[0]
                                 ax.plt_noise = self.pf_axes[n].plot(numpy.repeat(noise, len(y)), y,
                                                                     color="k", linestyle="dashed", lw=1)[0]
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
                             if self.CODE == 'gaussian_fit':
                                 # ax.plt_mean = ax.plot(mean, y, color='k', lw=1)[0]
                                 ax.plt_gau0 = ax.plot(gau0, y, color='r', lw=1)[0]
                                 ax.plt_gau1 = ax.plot(gau1, y, color='y', lw=1)[0]
                         else:
                             ax.plt.set_array(z[n].T.ravel())
                             if self.showprofile:
                                 ax.plt_profile.set_data(data['rti'][n], y)
                                 ax.plt_noise.set_data(numpy.repeat(noise, len(y)), y)
                             if self.CODE == 'spc_moments':
                                 ax.plt_mean.set_data(mean, y)
                             if self.CODE == 'gaussian_fit':
                                 # ax.plt_mean.set_data(mean, y)
                                 ax.plt_gau0.set_data(gau0, y)
                                 ax.plt_gau1.set_data(gau1, y)
                         self.titles.append('CH {}: {:3.2f}dB'.format(n, noise))
             class CrossSpectraPlot(Plot):
                 CODE = 'cspc'
                 colormap = 'jet'
                 plot_type = 'pcolor'
                 zmin_coh = None
                 zmax_coh = None
                 zmin_phase = None
                 zmax_phase = None
                 def setup(self):
                     self.ncols = 4
                     self.nplots = len(self.data.pairs) * 2
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.1 * self.ncols
                     self.height = 2.6 * self.nrows
                     self.ylabel = 'Range [km]'
                     self.showprofile = False
                     self.plots_adjust.update({'left': 0.08, 'right': 0.92, 'wspace': 0.5, 'hspace':0.4, 'top':0.95, 'bottom': 0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = dataOut.data_spc
                     cspc = dataOut.data_cspc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     meta['pairs'] = dataOut.pairsList
                     tmp = []
                     for n, pair in enumerate(meta['pairs']):
                         out = cspc[n] / numpy.sqrt(spc[pair[0]] * spc[pair[1]])
                         coh = numpy.abs(out)
                         phase = numpy.arctan2(out.imag, out.real) * 180 / numpy.pi
                         tmp.append(coh)
                         tmp.append(phase)
                     data['cspc'] = numpy.array(tmp)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     self.y = y
                     data = self.data[-1]
                     cspc = data['cspc']
                     for n in range(len(self.data.pairs)):
                         pair = self.data.pairs[n]
                         coh = cspc[n*2]
                         phase = cspc[n*2+1]
                         ax = self.axes[2 * n]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, coh.T,
                                                    vmin=0,
                                                    vmax=1,
                                                    cmap=plt.get_cmap(self.colormap_coh)
                                                    )
                         else:
                             ax.plt.set_array(coh.T.ravel())
                         self.titles.append(
                             'Coherence Ch{} * Ch{}'.format(pair[0], pair[1]))
                         ax = self.axes[2 * n + 1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, phase.T,
                                                    vmin=-180,
                                                    vmax=180,
                                                    cmap=plt.get_cmap(self.colormap_phase)
                                                    )
                         else:
                             ax.plt.set_array(phase.T.ravel())
                         self.titles.append('Phase CH{} * CH{}'.format(pair[0], pair[1]))
             class RTIPlot(Plot):
                 '''
                 Plot for RTI data
                 '''
                 CODE = 'rti'
                 colormap = 'jet'
                 plot_type = 'pcolorbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
+                    print("ch",self.data.channels)
                     self.nrows = len(self.data.channels)
                     self.nplots = len(self.data.channels)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.cb_label = 'dB'
                     self.plots_adjust.update({'hspace':0.8, 'left': 0.1, 'bottom': 0.08, 'right':0.95})
                     self.titles = ['{} Channel {}'.format(
                         self.CODE.upper(), x) for x in range(self.nrows)]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['rti'] = dataOut.getPower()
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     self.x = self.data.times
                     self.y = self.data.yrange
                     self.z = self.data[self.CODE]
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmin = self.zmin if self.zmin else numpy.min(self.z)
                         self.zmax = self.zmax if self.zmax else numpy.max(self.z)
                         data = self.data[-1]
                         if ax.firsttime:
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
+                                print("test-------------------------------------1")
                                 ax.plot_profile = self.pf_axes[n].plot(
                                     data['rti'][n], self.y)[0]
                                 ax.plot_noise = self.pf_axes[n].plot(numpy.repeat(data['noise'][n], len(self.y)), self.y,
                                                                      color="k", linestyle="dashed", lw=1)[0]
                         else:
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T,
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=plt.get_cmap(self.colormap)
                                                    )
                             if self.showprofile:
                                 ax.plot_profile.set_data(data['rti'][n], self.y)
                                 ax.plot_noise.set_data(numpy.repeat(
                                     data['noise'][n], len(self.y)), self.y)
             class CoherencePlot(RTIPlot):
                 '''
                 Plot for Coherence data
                 '''
                 CODE = 'coh'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = len(self.data.pairs)
                     self.nplots = len(self.data.pairs)
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Time'
                     self.plots_adjust.update({'hspace':0.6, 'left': 0.1, 'bottom': 0.1,'right':0.95})
                     if self.CODE == 'coh':
                         self.cb_label = ''
                         self.titles = [
                             'Coherence Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                     else:
                         self.cb_label = 'Degrees'
                         self.titles = [
                             'Phase Map Ch{} * Ch{}'.format(x[0], x[1]) for x in self.data.pairs]
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['coh'] = dataOut.getCoherence()
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class PhasePlot(CoherencePlot):
                 '''
                 Plot for Phase map data
                 '''
                 CODE = 'phase'
                 colormap = 'seismic'
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['phase'] = dataOut.getCoherence(phase=True)
                     meta['pairs'] = dataOut.pairsList
                     return data, meta
             class NoisePlot(Plot):
                 '''
                 Plot for noise
                 '''
                 CODE = 'noise'
                 plot_type = 'scatterbuffer'
                 def setup(self):
                     self.xaxis = 'time'
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.ylabel = 'Intensity [dB]'
                     self.xlabel = 'Time'
                     self.titles = ['Noise']
                     self.colorbar = False
                     self.plots_adjust.update({'right': 0.85 })
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data['noise'] = 10*numpy.log10(dataOut.getNoise()/dataOut.normFactor).reshape(dataOut.nChannels, 1)
                     meta['yrange'] = numpy.array([])
                     return data, meta
                 def plot(self):
                     x = self.data.times
                     xmin = self.data.min_time
                     xmax = xmin + self.xrange * 60 * 60
                     Y = self.data['noise']
                     if self.axes[0].firsttime:
                         self.ymin = numpy.nanmin(Y) - 5
                         self.ymax = numpy.nanmax(Y) + 5
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].plot(x, y, lw=1, label='Ch{}'.format(ch))
                         plt.legend(bbox_to_anchor=(1.18, 1.0))
                     else:
                         for ch in self.data.channels:
                             y = Y[ch]
                             self.axes[0].lines[ch].set_data(x, y)
             class PowerProfilePlot(Plot):
                 CODE = 'pow_profile'
                 plot_type = 'scatter'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots = 1
                     self.height = 4
                     self.width = 3
                     self.ylabel = 'Range [km]'
                     self.xlabel = 'Intensity [dB]'
                     self.titles = ['Power Profile']
                     self.colorbar = False
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     data[self.CODE] = dataOut.getPower()
                     return data, meta
                 def plot(self):
                     y = self.data.yrange
                     self.y = y
                     x = self.data[-1][self.CODE]
                     if self.xmin is None: self.xmin = numpy.nanmin(x)*0.9
                     if self.xmax is None: self.xmax = numpy.nanmax(x)*1.1
                     if self.axes[0].firsttime:
                         for ch in self.data.channels:
                             self.axes[0].plot(x[ch], y, lw=1, label='Ch{}'.format(ch))
                         plt.legend()
                     else:
                         for ch in self.data.channels:
                             self.axes[0].lines[ch].set_data(x[ch], y)
             class SpectraCutPlot(Plot):
                 CODE = 'spc_cut'
                 plot_type = 'scatter'
                 buffering = False
                 def setup(self):
                     self.nplots = len(self.data.channels)
                     self.ncols = int(numpy.sqrt(self.nplots) + 0.9)
                     self.nrows = int((1.0 * self.nplots / self.ncols) + 0.9)
                     self.width = 3.4 * self.ncols + 1.5
                     self.height = 3 * self.nrows
                     self.ylabel = 'Power [dB]'
                     self.colorbar = False
                     self.plots_adjust.update({'left':0.1, 'hspace':0.3, 'right': 0.75, 'bottom':0.08})
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     spc = 10*numpy.log10(dataOut.data_pre[0]/dataOut.normFactor)
                     data['spc'] = spc
                     meta['xrange'] = (dataOut.getFreqRange(1)/1000., dataOut.getAcfRange(1), dataOut.getVelRange(1))
                     if self.CODE == 'cut_gaussian_fit':
                         data['gauss_fit0'] = 10*numpy.log10(dataOut.GaussFit0/dataOut.normFactor)
                         data['gauss_fit1'] = 10*numpy.log10(dataOut.GaussFit1/dataOut.normFactor)
                     return data, meta
                 def plot(self):
                     if self.xaxis == "frequency":
                         x = self.data.xrange[0][1:]
                         self.xlabel = "Frequency (kHz)"
                     elif self.xaxis == "time":
                         x = self.data.xrange[1]
                         self.xlabel = "Time (ms)"
                     else:
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     if self.CODE == 'cut_gaussian_fit':
                         x = self.data.xrange[2][:-1]
                         self.xlabel = "Velocity (m/s)"
                     self.titles = []
                     y = self.data.yrange
                     data = self.data[-1]
                     z = data['spc']
                     if self.height_index:
                         index = numpy.array(self.height_index)
                     else:
                         index = numpy.arange(0, len(y), int((len(y))/9))
                     for n, ax in enumerate(self.axes):
                         if self.CODE == 'cut_gaussian_fit':
                             gau0 = data['gauss_fit0']
                             gau1 = data['gauss_fit1']
                         if ax.firsttime:
                             self.xmax = self.xmax if self.xmax else numpy.nanmax(x)
                             self.xmin = self.xmin if self.xmin else -self.xmax
                             self.ymin = self.ymin if self.ymin else numpy.nanmin(z)
                             self.ymax = self.ymax if self.ymax else numpy.nanmax(z)
                             ax.plt = ax.plot(x, z[n, :, index].T, lw=0.25)
                             if self.CODE == 'cut_gaussian_fit':
                                 ax.plt_gau0 = ax.plot(x, gau0[n, :, index].T, lw=1, linestyle='-.')
                                 for i, line in enumerate(ax.plt_gau0):
                                     line.set_color(ax.plt[i].get_color())
                                 ax.plt_gau1 = ax.plot(x, gau1[n, :, index].T, lw=1, linestyle='--')
                                 for i, line in enumerate(ax.plt_gau1):
                                     line.set_color(ax.plt[i].get_color())
                             labels = ['Range = {:2.1f}km'.format(y[i]) for i in index]
                             self.figures[0].legend(ax.plt, labels, loc='center right')
                         else:
                             for i, line in enumerate(ax.plt):
                                 line.set_data(x, z[n, :, index[i]].T)
                             for i, line in enumerate(ax.plt_gau0):
                                 line.set_data(x, gau0[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                             for i, line in enumerate(ax.plt_gau1):
                                 line.set_data(x, gau1[n, :, index[i]].T)
                                 line.set_color(ax.plt[i].get_color())
                         self.titles.append('CH {}'.format(n))
             class BeaconPhase(Plot):
                 __isConfig = None
                 __nsubplots = None
                 PREFIX = 'beacon_phase'
                 def __init__(self):
                     Plot.__init__(self)
                     self.timerange = 24*60*60
                     self.isConfig = False
                     self.__nsubplots = 1
                     self.counter_imagwr = 0
                     self.WIDTH = 800
                     self.HEIGHT = 400
                     self.WIDTHPROF = 120
                     self.HEIGHTPROF = 0
                     self.xdata = None
                     self.ydata = None
                     self.PLOT_CODE = BEACON_CODE
                     self.FTP_WEI = None
                     self.EXP_CODE = None
                     self.SUB_EXP_CODE = None
                     self.PLOT_POS = None
                     self.filename_phase = None
                     self.figfile = None
                     self.xmin = None
                     self.xmax = None
                 def getSubplots(self):
                     ncol = 1
                     nrow = 1
                     return nrow, ncol
                 def setup(self, id, nplots, wintitle, showprofile=True, show=True):
                     self.__showprofile = showprofile
                     self.nplots = nplots
                     ncolspan = 7
                     colspan = 6
                     self.__nsubplots = 2
                     self.createFigure(id = id,
                                       wintitle = wintitle,
                                       widthplot = self.WIDTH+self.WIDTHPROF,
                                       heightplot = self.HEIGHT+self.HEIGHTPROF,
                                       show=show)
                     nrow, ncol = self.getSubplots()
                     self.addAxes(nrow, ncol*ncolspan, 0, 0, colspan, 1)
                 def save_phase(self, filename_phase):
                     f = open(filename_phase,'w+')
                     f.write('\n\n')
                     f.write('JICAMARCA RADIO OBSERVATORY - Beacon Phase \n')
                     f.write('DD MM YYYY  HH MM SS   pair(2,0) pair(2,1) pair(2,3) pair(2,4)\n\n' )
                     f.close()
                 def save_data(self, filename_phase, data, data_datetime):
                     f=open(filename_phase,'a')
                     timetuple_data = data_datetime.timetuple()
                     day = str(timetuple_data.tm_mday)
                     month = str(timetuple_data.tm_mon)
                     year = str(timetuple_data.tm_year)
                     hour = str(timetuple_data.tm_hour)
                     minute = str(timetuple_data.tm_min)
                     second = str(timetuple_data.tm_sec)
                     f.write(day+' '+month+' '+year+'  '+hour+' '+minute+' '+second+'   '+str(data[0])+'   '+str(data[1])+'   '+str(data[2])+'   '+str(data[3])+'\n')
                     f.close()
                 def plot(self):
                     log.warning('TODO: Not yet implemented...')
                 def run(self, dataOut, id, wintitle="", pairsList=None, showprofile='True',
                         xmin=None, xmax=None, ymin=None, ymax=None, hmin=None, hmax=None,
                         timerange=None,
                         save=False, figpath='./', figfile=None, show=True, ftp=False, wr_period=1,
                         server=None, folder=None, username=None, password=None,
                         ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0):
                     if dataOut.flagNoData:
                         return dataOut
                     if not isTimeInHourRange(dataOut.datatime, xmin, xmax):
                         return
                     if pairsList == None:
                         pairsIndexList = dataOut.pairsIndexList[:10]
                     else:
                         pairsIndexList = []
                         for pair in pairsList:
                             if pair not in dataOut.pairsList:
                                 raise ValueError("Pair %s is not in dataOut.pairsList" %(pair))
                             pairsIndexList.append(dataOut.pairsList.index(pair))
                     if pairsIndexList == []:
                         return
              #         if len(pairsIndexList) > 4:
              #             pairsIndexList = pairsIndexList[0:4]
                     hmin_index = None
                     hmax_index = None
                     if hmin != None and hmax != None:
                         indexes = numpy.arange(dataOut.nHeights)
                         hmin_list = indexes[dataOut.heightList >= hmin]
                         hmax_list = indexes[dataOut.heightList <= hmax]
                         if hmin_list.any():
                             hmin_index = hmin_list[0]
                         if hmax_list.any():
                             hmax_index = hmax_list[-1]+1
                     x = dataOut.getTimeRange()
                     thisDatetime = dataOut.datatime
                     title = wintitle + " Signal Phase" # : %s" %(thisDatetime.strftime("%d-%b-%Y"))
                     xlabel = "Local Time"
                     ylabel = "Phase (degrees)"
                     update_figfile = False
                     nplots = len(pairsIndexList)
                     #phase = numpy.zeros((len(pairsIndexList),len(dataOut.beacon_heiIndexList)))
                     phase_beacon = numpy.zeros(len(pairsIndexList))
                     for i in range(nplots):
                         pair = dataOut.pairsList[pairsIndexList[i]]
                         ccf = numpy.average(dataOut.data_cspc[pairsIndexList[i], :, hmin_index:hmax_index], axis=0)
                         powa = numpy.average(dataOut.data_spc[pair[0], :, hmin_index:hmax_index], axis=0)
                         powb = numpy.average(dataOut.data_spc[pair[1], :, hmin_index:hmax_index], axis=0)
                         avgcoherenceComplex = ccf/numpy.sqrt(powa*powb)
                         phase = numpy.arctan2(avgcoherenceComplex.imag, avgcoherenceComplex.real)*180/numpy.pi
                         if dataOut.beacon_heiIndexList:
                             phase_beacon[i] = numpy.average(phase[dataOut.beacon_heiIndexList])
                         else:
                             phase_beacon[i] = numpy.average(phase)
                     if not self.isConfig:
                         nplots = len(pairsIndexList)
                         self.setup(id=id,
                                    nplots=nplots,
                                    wintitle=wintitle,
                                    showprofile=showprofile,
                                    show=show)
                         if timerange != None:
                             self.timerange = timerange
                         self.xmin, self.xmax = self.getTimeLim(x, xmin, xmax, timerange)
                         if ymin == None: ymin = 0
                         if ymax == None: ymax = 360
                         self.FTP_WEI = ftp_wei
                         self.EXP_CODE = exp_code
                         self.SUB_EXP_CODE = sub_exp_code
                         self.PLOT_POS = plot_pos
                         self.name = thisDatetime.strftime("%Y%m%d_%H%M%S")
                         self.isConfig = True
                         self.figfile = figfile
                         self.xdata = numpy.array([])
                         self.ydata = numpy.array([])
                         update_figfile = True
                         #open file beacon phase
                         path = '%s%03d' %(self.PREFIX, self.id)
                         beacon_file = os.path.join(path,'%s.txt'%self.name)
                         self.filename_phase = os.path.join(figpath,beacon_file)
                         #self.save_phase(self.filename_phase)
                     #store data beacon phase
                     #self.save_data(self.filename_phase, phase_beacon, thisDatetime)
                     self.setWinTitle(title)
                     title = "Phase Plot %s" %(thisDatetime.strftime("%Y/%m/%d %H:%M:%S"))
                     legendlabels = ["Pair (%d,%d)"%(pair[0], pair[1]) for pair in dataOut.pairsList]
                     axes = self.axesList[0]
                     self.xdata = numpy.hstack((self.xdata, x[0:1]))
                     if len(self.ydata)==0:
                         self.ydata = phase_beacon.reshape(-1,1)
                     else:
                         self.ydata = numpy.hstack((self.ydata, phase_beacon.reshape(-1,1)))
                     axes.pmultilineyaxis(x=self.xdata, y=self.ydata,
                                 xmin=self.xmin, xmax=self.xmax, ymin=ymin, ymax=ymax,
                                 xlabel=xlabel, ylabel=ylabel, title=title, legendlabels=legendlabels, marker='x', markersize=8, linestyle="solid",
                                 XAxisAsTime=True, grid='both'
                                 )
                     self.draw()
                     if dataOut.ltctime >= self.xmax:
                         self.counter_imagwr = wr_period
                         self.isConfig = False
                         update_figfile = True
                     self.save(figpath=figpath,
                               figfile=figfile,
                               save=save,
                               ftp=ftp,
                               wr_period=wr_period,
                               thisDatetime=thisDatetime,
                               update_figfile=update_figfile)
                     return dataOut

schainpy/model/io/jroIO_base.py +35 -1

             """
             Created on Jul 2, 2014
             @author: roj-idl71
             """
             import os
             import sys
             import glob
             import time
             import numpy
             import fnmatch
             import inspect
             import time
             import datetime
             import zmq
             from schainpy.model.proc.jroproc_base import Operation, MPDecorator
             from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
             from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
             from schainpy.utils import log
             import schainpy.admin
             LOCALTIME = True
             DT_DIRECTIVES = {
                 '%Y': 4,
                 '%y': 2,
                 '%m': 2,
                 '%d': 2,
                 '%j': 3,
                 '%H': 2,
                 '%M': 2,
                 '%S': 2,
                 '%f': 6
             }
             def isNumber(cad):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float(cad)
                     return True
                 except:
                     return False
             def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return 0
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print("Skipping the file %s because it has not a valid header" % (filename))
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def isTimeInRange(thisTime, startTime, endTime):
                 if endTime >= startTime:
                     if (thisTime < startTime) or (thisTime > endTime):
                         return 0
                     return 1
                 else:
                     if (thisTime < startTime) and (thisTime > endTime):
                         return 0
                     return 1
             def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename, 'rb')
                 except IOError:
                     print("The file %s can't be opened" % (filename))
                     return None
                 firstBasicHeaderObj = BasicHeader(LOCALTIME)
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 lastBasicHeaderObj = BasicHeader(LOCALTIME)
                 sts = firstBasicHeaderObj.read(fp)
                 if not(sts):
                     print("[Reading] Skipping the file %s because it has not a valid header" % (filename))
                     return None
                 if not systemHeaderObj.read(fp):
                     return None
                 if not radarControllerHeaderObj.read(fp):
                     return None
                 if not processingHeaderObj.read(fp):
                     return None
                 filesize = os.path.getsize(filename)
                 offset = processingHeaderObj.blockSize + 24  # header size
                 if filesize <= offset:
                     print("[Reading] %s: This file has not enough data" % filename)
                     return None
                 fp.seek(-offset, 2)
                 sts = lastBasicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = lastBasicHeaderObj.datatime
                 thisTime_last_block = thisDatetime.time()
                 thisDatetime = firstBasicHeaderObj.datatime
                 thisDate = thisDatetime.date()
                 thisTime_first_block = thisDatetime.time()
                 # General case
                 #           o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
                 #-----------o----------------------------o-----------
                 #       startTime                     endTime
                 if endTime >= startTime:
                     if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
                         return None
                     return thisDatetime
                 # If endTime < startTime then endTime belongs to the next day
                 #<<<<<<<<<<<o                            o>>>>>>>>>>>
                 #-----------o----------------------------o-----------
                 #        endTime                    startTime
                 if (thisDate == startDate) and (thisTime_last_block < startTime):
                     return None
                 if (thisDate == endDate) and (thisTime_first_block > endTime):
                     return None
                 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
                     return None
                 return thisDatetime
             def isFolderInDateRange(folder, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     folder            :    nombre completo del directorio.
                                            Su formato deberia ser "/path_root/?YYYYDDD"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el directorio no tiene el formato adecuado
                 """
                 basename = os.path.basename(folder)
                 if not isRadarFolder(basename):
                     print("The folder %s has not the rigth format" % folder)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFolder(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def isFileInDateRange(filename, startDate=None, endDate=None):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                                            Su formato deberia ser "?YYYYDDDsss"
                                             siendo:
                                                 YYYY    :    Anio         (ejemplo 2015)
                                                 DDD     :    Dia del anio (ejemplo 305)
                                                 sss     :    set
                     startDate          :    fecha inicial del rango seleccionado en formato datetime.date
                     endDate            :    fecha final del rango seleccionado en formato datetime.date
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no tiene el formato adecuado
                 """
                 basename = os.path.basename(filename)
                 if not isRadarFile(basename):
                     print("The filename %s has not the rigth format" % filename)
                     return 0
                 if startDate and endDate:
                     thisDate = getDateFromRadarFile(basename)
                     if thisDate < startDate:
                         return 0
                     if thisDate > endDate:
                         return 0
                 return 1
             def getFileFromSet(path, ext, set):
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     try:
                         year = int(thisFile[1:5])
                         doy = int(thisFile[5:8])
                     except:
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 myfile = fnmatch.filter(
                     validFilelist, '*%4.4d%3.3d%3.3d*' % (year, doy, set))
                 if len(myfile) != 0:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s' % (year, doy, set, ext.lower())
                     print('the filename %s does not exist' % filename)
                     print('...going to the last file: ')
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for thisFile in fileList:
                     year = thisFile[1:5]
                     if not isNumber(year):
                         continue
                     doy = thisFile[5:8]
                     if not isNumber(doy):
                         continue
                     year = int(year)
                     doy = int(doy)
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.append(thisFile)
                 if validFilelist:
                     validFilelist = sorted(validFilelist, key=str.lower)
                     return validFilelist[-1]
                 return None
             def isRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return 0
                 return 1
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return 0
                 return 1
             def getDateFromRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def getDateFromRadarFolder(folder):
                 try:
                     year = int(folder[1:5])
                     doy = int(folder[5:8])
                 except:
                     return None
                 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
                 return thisDate
             def parse_format(s, fmt):
                 for i in range(fmt.count('%')):
                     x = fmt.index('%')
                     d = DT_DIRECTIVES[fmt[x:x+2]]
                     fmt = fmt.replace(fmt[x:x+2], s[x:x+d])
                 return fmt
             class Reader(object):
                 c = 3E8
                 isConfig = False
                 dtype = None
                 pathList = []
                 filenameList = []
                 datetimeList = []
                 filename = None
                 ext = None
                 flagIsNewFile = 1
                 flagDiscontinuousBlock = 0
                 flagIsNewBlock = 0
                 flagNoMoreFiles = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 fileSizeByHeader = None
                 fileIndex = -1
                 profileIndex = None
                 blockIndex = 0
                 nTotalBlocks = 0
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
                 dataOut = None
                 getByBlock = False
                 path = None
                 startDate = None
                 endDate = None
                 startTime = datetime.time(0, 0, 0)
                 endTime = datetime.time(23, 59, 59)
                 set = None
                 expLabel = ""
                 online = False
                 delay = 60
                 nTries = 3  # quantity tries
                 nFiles = 3  # number of files for searching
                 walk = True
                 getblock = False
                 nTxs = 1
                 realtime = False
                 blocksize = 0
                 blocktime = None
                 warnings = True
                 verbose = True
                 server = None
                 format = None
                 oneDDict = None
                 twoDDict = None
                 independentParam = None
                 filefmt = None
                 folderfmt = None
                 open_file = open
                 open_mode = 'rb'
                 def run(self):
                     raise NotImplementedError
                 def getAllowedArgs(self):
                     if hasattr(self, '__attrs__'):
                         return self.__attrs__
                     else:
                         return inspect.getargspec(self.run).args
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def find_folders(self, path, startDate, endDate, folderfmt, last=False):
                     folders = [x for f in path.split(',')
                                for x in os.listdir(f) if os.path.isdir(os.path.join(f, x))]
                     folders.sort()
                     if last:
                         folders = [folders[-1]]
                     for folder in folders:
                         try:
                             dt = datetime.datetime.strptime(parse_format(folder, folderfmt), folderfmt).date()
                             if dt >= startDate and dt <= endDate:
                                 yield os.path.join(path, folder)
                             else:
                                 log.log('Skiping folder {}'.format(folder), self.name)
                         except Exception as e:
                             log.log('Skiping folder {}'.format(folder), self.name)
                             continue
                     return
                 def find_files(self, folders, ext, filefmt, startDate=None, endDate=None,
                                expLabel='', last=False):
                     for path in folders:
                         files = glob.glob1(path, '*{}'.format(ext))
                         files.sort()
                         if last:
                             if files:
                                 fo = files[-1]
                                 try:
                                     dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                     yield os.path.join(path, expLabel, fo)
                                 except Exception as e:
                                     pass
                                 return
                             else:
                                 return
                         for fo in files:
                             try:
                                 dt = datetime.datetime.strptime(parse_format(fo, filefmt), filefmt).date()
                                 if dt >= startDate and dt <= endDate:
                                     yield os.path.join(path, expLabel, fo)
                                 else:
                                     log.log('Skiping file {}'.format(fo), self.name)
                             except Exception as e:
                                 log.log('Skiping file {}'.format(fo), self.name)
                                 continue
                 def searchFilesOffLine(self, path, startDate, endDate,
                                        expLabel, ext, walk,
                                        filefmt, folderfmt):
                     """Search files in offline mode for the given arguments
                     Return:
                         Generator of files
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel)
                 def searchFilesOnLine(self, path, startDate, endDate,
                                       expLabel, ext, walk,
                                       filefmt, folderfmt):
                     """Search for the last file of the last folder
                     Arguments:
                         path        :    carpeta donde estan contenidos los files que contiene data
                         expLabel    :    Nombre del subexperimento (subfolder)
                         ext         :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         generator with the full path of last filename
                     """
                     if walk:
                         folders = self.find_folders(
                             path, startDate, endDate, folderfmt, last=True)
                     else:
                         folders = path.split(',')
                     return self.find_files(
                         folders, ext, filefmt, startDate, endDate, expLabel, last=True)
                 def setNextFile(self):
                     """Set the next file to be readed open it and parse de file header"""
                     while True:
                         if self.fp != None:
                             self.fp.close()
                         if self.online:
                             newFile = self.setNextFileOnline()
                         else:
                             newFile = self.setNextFileOffline()
                         if not(newFile):
                             if self.online:
                                 raise schainpy.admin.SchainError('Time to wait for new files reach')
                             else:
                                 if self.fileIndex == -1:
                                     raise schainpy.admin.SchainWarning('No files found in the given path')
                                 else:
                                     raise schainpy.admin.SchainWarning('No more files to read')
                         if self.verifyFile(self.filename):
                             break
                     log.log('Opening file: %s' % self.filename, self.name)
                     self.readFirstHeader()
                     self.nReadBlocks = 0
                 def setNextFileOnline(self):
                     """Check for the next file to be readed in online mode.
                     Set:
                         self.filename
                         self.fp
                         self.filesize
                     Return:
                         boolean
                     """
                     nextFile = True
                     nextDay = False
                     for nFiles in range(self.nFiles+1):
                         for nTries in range(self.nTries):
                             fullfilename, filename = self.checkForRealPath(nextFile, nextDay)
                             if fullfilename is not None:
                                 break
                             log.warning(
                                 "Waiting %0.2f sec for the next file: \"%s\" , try %02d ..." % (self.delay, filename, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                             nextFile = False
                             continue
                         if fullfilename is not None:
                             break
                         self.nTries = 1
                         nextFile = True
                         if nFiles == (self.nFiles - 1):
                             log.log('Trying with next day...', self.name)
                             nextDay = True
                             self.nTries = 3
                     if fullfilename:
                         self.fileSize = os.path.getsize(fullfilename)
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
                         if self.fp != None:
                             self.fp.close()
                         self.fp = self.open_file(fullfilename, self.open_mode)
                         self.flagNoMoreFiles = 0
                         self.fileIndex += 1
                         return 1
                     else:
                         return 0
                 def setNextFileOffline(self):
                     """Open the next file to be readed in offline mode"""
                     try:
                         filename = next(self.filenameList)
                         self.fileIndex +=1
                     except StopIteration:
                         self.flagNoMoreFiles = 1
                         return 0
                     self.filename = filename
                     self.fileSize = os.path.getsize(filename)
                     self.fp = self.open_file(filename, self.open_mode)
                     self.flagIsNewFile = 1
                     return 1
                 @staticmethod
                 def isDateTimeInRange(dt, startDate, endDate, startTime, endTime):
                     """Check if the given datetime is in range"""
                     if startDate <= dt.date() <= endDate:
                         if startTime <= dt.time() <= endTime:
                             return True
                     return False
                 def verifyFile(self, filename):
                     """Check for a valid file
                     Arguments:
                         filename -- full path filename
                     Return:
                         boolean
                     """
                     return True
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists"""
+                    if nextFile:
+                        self.set += 1
+                    if nextDay:
+                        self.set = 0
+                        self.doy += 1
+                    foldercounter = 0
+                    prefixDirList = [None, 'd', 'D']
+                    if self.ext.lower() == ".r":  # voltage
+                        prefixFileList = ['d', 'D']
+                    elif self.ext.lower() == ".pdata":  # spectra
+                        prefixFileList = ['p', 'P']
+                    elif self.ext.lower() == ".hdf5":  # HDF5
+                        prefixFileList = ['D', 'P']    # HDF5
-                    raise NotImplementedError
+                    # barrido por las combinaciones posibles
+                    for prefixDir in prefixDirList:
+                        thispath = self.path
+                        if prefixDir != None:
+                            # formo el nombre del directorio xYYYYDDD (x=d o x=D)
+                            if foldercounter == 0:
+                                thispath = os.path.join(self.path, "%s%04d%03d" %
+                                                        (prefixDir, self.year, self.doy))
+                            else:
+                                thispath = os.path.join(self.path, "%s%04d%03d_%02d" % (
+                                    prefixDir, self.year, self.doy, foldercounter))
+                        for prefixFile in prefixFileList:  # barrido por las dos combinaciones posibles de "D"
+                            # formo el nombre del file xYYYYDDDSSS.ext
+                            filename = "%s%04d%03d%03d%s" % (prefixFile, self.year, self.doy, self.set, self.ext)
+                            fullfilename = os.path.join(
+                                thispath, filename)
+                            if os.path.exists(fullfilename):
+                                return fullfilename, filename
+                    return None, filename
+                    #raise NotImplementedError
                 def readFirstHeader(self):
                     """Parse the file header"""
                     pass
                 def waitDataBlock(self, pointer_location, blocksize=None):
                     """
                     """
                     currentPointer = pointer_location
                     if blocksize is None:
                         neededSize = self.processingHeaderObj.blockSize  # + self.basicHeaderSize
                     else:
                         neededSize = blocksize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             return 1
                         log.warning(
                             "Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1),
                             self.name
                             )
                         time.sleep(self.delay)
                     return 0
             class JRODataReader(Reader):
                 utc = 0
                 nReadBlocks = 0
                 foldercounter = 0
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 __isFirstTimeOnline = 1
                 filefmt = "*%Y%j***"
                 folderfmt = "*%Y%j"
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'online', 'delay', 'walk']
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def checkForRealPath(self, nextFile, nextDay):
                     """Check if the next file to be readed exists.
                     Example    :
                         nombre correcto del file es  .../.../D2009307/P2009307367.ext
                         Entonces la funcion prueba con las siguientes combinaciones
                             .../.../y2009307367.ext
                             .../.../Y2009307367.ext
                             .../.../x2009307/y2009307367.ext
                             .../.../x2009307/Y2009307367.ext
                             .../.../X2009307/y2009307367.ext
                             .../.../X2009307/Y2009307367.ext
                         siendo para este caso, la ultima combinacion de letras, identica al file buscado
                     Return:
                         str -- fullpath of the file
                     """
                     if nextFile:
                         self.set += 1
                     if nextDay:
                         self.set = 0
                         self.doy += 1
                     foldercounter = 0
                     prefixDirList = [None, 'd', 'D']
                     if self.ext.lower() == ".r":  # voltage
                         prefixFileList = ['d', 'D']
                     elif self.ext.lower() == ".pdata":  # spectra
                         prefixFileList = ['p', 'P']
                     # barrido por las combinaciones posibles
                     for prefixDir in prefixDirList:
                         thispath = self.path
                         if prefixDir != None:
                             # formo el nombre del directorio xYYYYDDD (x=d o x=D)
                             if foldercounter == 0:
                                 thispath = os.path.join(self.path, "%s%04d%03d" %
                                                         (prefixDir, self.year, self.doy))
                             else:
                                 thispath = os.path.join(self.path, "%s%04d%03d_%02d" % (
                                     prefixDir, self.year, self.doy, foldercounter))
                         for prefixFile in prefixFileList:  # barrido por las dos combinaciones posibles de "D"
                             # formo el nombre del file xYYYYDDDSSS.ext
                             filename = "%s%04d%03d%03d%s" % (prefixFile, self.year, self.doy, self.set, self.ext)
                             fullfilename = os.path.join(
                                 thispath, filename)
                             if os.path.exists(fullfilename):
                                 return fullfilename, filename
                     return None, filename
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range(self.nTries):
                         self.fp.close()
                         self.fp = open(self.filename, 'rb')
                         self.fp.seek(currentPointer)
                         self.fileSize = os.path.getsize(self.filename)
                         currentSize = self.fileSize - currentPointer
                         if (currentSize >= neededSize):
                             self.basicHeaderObj.read(self.fp)
                             return 1
                         if self.fileSize == self.fileSizeByHeader:
                             #                self.flagEoF = True
                             return 0
                         print("[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries + 1))
                         time.sleep(self.delay)
                     return 0
                 def __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.realtime:
                         self.flagDiscontinuousBlock = 1
                         if not(self.setNextFile()):
                             return 0
                         else:
                             return 1
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.basicHeaderObj.read(self.fp)
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if self.__waitNewBlock():
                         self.lastUTTime = self.basicHeaderObj.utc
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime
                     self.lastUTTime = self.basicHeaderObj.utc
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     while True:
                         if not(self.__setNewBlock()):
                             continue
                         if not(self.readBlock()):
                             return 0
                         self.getBasicHeader()
                         if not self.isDateTimeInRange(self.dataOut.datatime, self.startDate, self.endDate, self.startTime, self.endTime):
                             print("[Reading] Block No. %d/%d -> %s [Skipping]" % (self.nReadBlocks,
                                                                                   self.processingHeaderObj.dataBlocksPerFile,
                                                                                   self.dataOut.datatime.ctime()))
                             continue
                         break
                     if self.verbose:
                         print("[Reading] Block No. %d/%d -> %s" % (self.nReadBlocks,
                                                                    self.processingHeaderObj.dataBlocksPerFile,
                                                                    self.dataOut.datatime.ctime()))
                     return 1
                 def readFirstHeader(self):
                     self.basicHeaderObj.read(self.fp)
                     self.systemHeaderObj.read(self.fp)
                     self.radarControllerHeaderObj.read(self.fp)
                     self.processingHeaderObj.read(self.fp)
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.processFlags &
                                                PROCFLAG.DATATYPE_MASK)) - numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
                     else:
                         raise ValueError('Data type was not defined')
                     self.dtype = datatype_str
                     #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + \
                         self.firstHeaderSize + self.basicHeaderSize * \
                         (self.processingHeaderObj.dataBlocksPerFile - 1)
                     #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
                     #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def verifyFile(self, filename):
                     flag = True
                     try:
                         fp = open(filename, 'rb')
                     except IOError:
                         log.error("File {} can't be opened".format(filename), self.name)
                         return False
                     if self.online and self.waitDataBlock(0):
                         pass
                     basicHeaderObj = BasicHeader(LOCALTIME)
                     systemHeaderObj = SystemHeader()
                     radarControllerHeaderObj = RadarControllerHeader()
                     processingHeaderObj = ProcessingHeader()
                     if not(basicHeaderObj.read(fp)):
                         flag = False
                     if not(systemHeaderObj.read(fp)):
                         flag = False
                     if not(radarControllerHeaderObj.read(fp)):
                         flag = False
                     if not(processingHeaderObj.read(fp)):
                         flag = False
                     if not self.online:
                         dt1 = basicHeaderObj.datatime
                         pos = self.fileSize-processingHeaderObj.blockSize-24
                         if pos<0:
                             flag = False
                             log.error('Invalid size for file: {}'.format(self.filename), self.name)
                         else:
                             fp.seek(pos)
                             if not(basicHeaderObj.read(fp)):
                                 flag = False
                         dt2 = basicHeaderObj.datatime
                         if not self.isDateTimeInRange(dt1, self.startDate, self.endDate, self.startTime, self.endTime) and not \
                                 self.isDateTimeInRange(dt2, self.startDate, self.endDate, self.startTime, self.endTime):
                             flag = False
                     fp.close()
                     return flag
                 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
                     path_empty = True
                     dateList = []
                     pathList = []
                     multi_path = path.split(',')
                     if not walk:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             fileList = glob.glob1(single_path, "*" + ext)
                             if not fileList:
                                 continue
                             path_empty = False
                             fileList.sort()
                             for thisFile in fileList:
                                 if not os.path.isfile(os.path.join(single_path, thisFile)):
                                     continue
                                 if not isRadarFile(thisFile):
                                     continue
                                 if not isFileInDateRange(thisFile, startDate, endDate):
                                     continue
                                 thisDate = getDateFromRadarFile(thisFile)
                                 if thisDate in dateList or single_path in pathList:
                                     continue
                                 dateList.append(thisDate)
                                 pathList.append(single_path)
                     else:
                         for single_path in multi_path:
                             if not os.path.isdir(single_path):
                                 continue
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_path, thisPath)):
                                     continue
                                 if not isRadarFolder(thisPath):
                                     continue
                                 if not isFolderInDateRange(thisPath, startDate, endDate):
                                     continue
                                 dirList.append(thisPath)
                             if not dirList:
                                 continue
                             dirList.sort()
                             for thisDir in dirList:
                                 datapath = os.path.join(single_path, thisDir, expLabel)
                                 fileList = glob.glob1(datapath, "*" + ext)
                                 if not fileList:
                                     continue
                                 path_empty = False
                                 thisDate = getDateFromRadarFolder(thisDir)
                                 pathList.append(datapath)
                                 dateList.append(thisDate)
                     dateList.sort()
                     if walk:
                         pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
                     else:
                         pattern_path = multi_path[0]
                     if path_empty:
                         raise schainpy.admin.SchainError("[Reading] No *%s files in %s for %s to %s" % (ext, pattern_path, startDate, endDate))
                     else:
                         if not dateList:
                             raise schainpy.admin.SchainError("[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" % (startDate, endDate, ext, path))
                     if include_path:
                         return dateList, pathList
                     return dateList
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.server is not None:
                         if 'tcp://' in self.server:
                             address = server
                         else:
                             address = 'ipc:///tmp/%s' % self.server
                         self.server = address
                         self.context = zmq.Context()
                         self.receiver = self.context.socket(zmq.PULL)
                         self.receiver.connect(self.server)
                         time.sleep(0.5)
                         print('[Starting] ReceiverData from {}'.format(self.server))
                     else:
                         self.server = None
                         if self.path == None:
                             raise ValueError("[Reading] The path is not valid")
                         if self.online:
                             log.log("[Reading] Searching files in online mode...", self.name)
                             for nTries in range(self.nTries):
                                 fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                     self.endDate, self.expLabel, self.ext, self.walk,
                                     self.filefmt, self.folderfmt)
                                 try:
                                     fullpath = next(fullpath)
                                 except:
                                     fullpath = None
                                 if fullpath:
                                     break
                                 log.warning(
                                     'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                         self.delay, self.path, nTries + 1),
                                     self.name)
                                 time.sleep(self.delay)
                             if not(fullpath):
                                 raise schainpy.admin.SchainError(
                                     'There isn\'t any valid file in {}'.format(self.path))
                             pathname, filename = os.path.split(fullpath)
                             self.year = int(filename[1:5])
                             self.doy = int(filename[5:8])
                             self.set = int(filename[8:11]) - 1
                         else:
                             log.log("Searching files in {}".format(self.path), self.name)
                             self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                         self.setNextFile()
                     return
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond / \
 . + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
                     self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                     self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds / self.nTxs
                 def getFirstHeader(self):
                     raise NotImplementedError
                 def getData(self):
                     raise NotImplementedError
                 def hasNotDataInBuffer(self):
                     raise NotImplementedError
                 def readBlock(self):
                     raise NotImplementedError
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print("[Reading] Number of read blocks per file %04d" % self.nReadBlocks)
                 def printTotalBlocks(self):
                     print("[Reading] Number of read blocks %04d" % self.nTotalBlocks)
                 def run(self, **kwargs):
                     """
                     Arguments:
                         path        :
                         startDate   :
                         endDate     :
                         startTime   :
                         endTime     :
                         set         :
                         expLabel    :
                         ext         :
                         online      :
                         delay       :
                         walk        :
                         getblock    :
                         nTxs        :
                         realtime    :
                         blocksize   :
                         blocktime   :
                         skip        :
                         cursor      :
                         warnings    :
                         server      :
                         verbose     :
                         format      :
                         oneDDict    :
                         twoDDict    :
                         independentParam    :
                     """
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.server is None:
                         self.getData()
                     else:
                         self.getFromServer()
             class JRODataWriter(Reader):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 fileDate = None
                 def __init__(self, dataOut=None):
                     raise NotImplementedError
                 def hasAllDataInBuffer(self):
                     raise NotImplementedError
                 def setBlockDimension(self):
                     raise NotImplementedError
                 def writeBlock(self):
                     raise NotImplementedError
                 def putData(self):
                     raise NotImplementedError
                 def getDtypeWidth(self):
                     dtype_index = get_dtype_index(self.dtype)
                     dtype_width = get_dtype_width(dtype_index)
                     return dtype_width
                 def getProcessFlags(self):
                     processFlags = 0
                     dtype_index = get_dtype_index(self.dtype)
                     procflag_dtype = get_procflag_dtype(dtype_index)
                     processFlags += procflag_dtype
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code is not None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     if self.dataOut.type == "Spectra":
                         if self.dataOut.nIncohInt > 1:
                             processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                         if self.dataOut.data_dc is not None:
                             processFlags += PROCFLAG.SAVE_CHANNELS_DC
                         if self.dataOut.flagShiftFFT:
                             processFlags += PROCFLAG.SHIFT_FFT_DATA
                     return processFlags
                 def setBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize  # bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
                     utc = numpy.floor(self.dataOut.utctime)
                     milisecond = (self.dataOut.utctime - utc) * 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise NotImplementedError
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
             #        CALCULAR PARAMETROS
                     sizeLongHeader = self.systemHeaderObj.size + \
                         self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     self.writeBlock()
                     print("[Writing] Block No. %d/%d" % (self.blockIndex,
                                                          self.processingHeaderObj.dataBlocksPerFile))
                     return 1
                 def setNextFile(self):
                     """Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     if not os.path.exists(path):
                         os.mkdir(path)
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year, timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     setFile = self.setFile
                     if not(os.path.exists(fullpath)):
                         os.mkdir(fullpath)
                         setFile = -1  # inicializo mi contador de seteo
                     else:
                         filesList = os.listdir(fullpath)
                         if len(filesList) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber(filen[8:11]):
                                 # inicializo mi contador de seteo al seteo del ultimo file
                                 setFile = int(filen[8:11])
                             else:
                                 setFile = -1
                         else:
                             setFile = -1  # inicializo mi contador de seteo
                     setFile += 1
                     # If this is a new day it resets some values
                     if self.dataOut.datatime.date() > self.fileDate:
                         setFile = 0
                         self.nTotalBlocks = 0
                     filen = '{}{:04d}{:03d}{:03d}{}'.format(
                             self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext)
                     filename = os.path.join(path, subfolder, filen)
                     fp = open(filename, 'wb')
                     self.blockIndex = 0
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.fileDate = self.dataOut.datatime.date()
                     self.setFirstHeader()
                     print('[Writing] Opening file: %s' % self.filename)
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path                :    directory where data will be saved
                         profilesPerBlock    :    number of profiles per block
                         set                 :    initial file set
                         datatype            :    An integer number that defines data type:
 : int8  (1 byte)
 : int16 (2 bytes)
 : int32 (4 bytes)
 : int64 (8 bytes)
 : float32 (4 bytes)
 : double64 (8 bytes)
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     self.ext = ext.lower()
                     self.path = path
                     if set is None:
                         self.setFile = -1
                     else:
                         self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     self.fileDate = self.dataOut.datatime.date()
                     self.dtype = self.dataOut.dtype
                     if datatype is not None:
                         self.dtype = get_numpy_dtype(datatype)
                     if not(self.setNextFile()):
                         print("[Writing] There isn't a next file")
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, path, blocksPerFile=100, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock,
                                    set=set, ext=ext, datatype=datatype, **kwargs)
                         self.isConfig = True
                     self.dataOut = dataOut
                     self.putData()
                     return self.dataOut
             @MPDecorator
             class printInfo(Operation):
                 def __init__(self):
                     Operation.__init__(self)
                     self.__printInfo = True
                 def run(self, dataOut, headers = ['systemHeaderObj', 'radarControllerHeaderObj', 'processingHeaderObj']):
                     if self.__printInfo == False:
                         return
                     for header in headers:
                         if hasattr(dataOut, header):
                             obj = getattr(dataOut, header)
                             if hasattr(obj, 'printInfo'):
                                 obj.printInfo()
                             else:
                                 print(obj)
                         else:
                             log.warning('Header {} Not found in object'.format(header))
                     self.__printInfo = False

schainpy/model/io/jroIO_digitalRF.py +11 -6

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             # SUBCHANNELS EN VEZ DE CHANNELS
             # BENCHMARKS -> PROBLEMAS CON ARCHIVOS GRANDES -> INCONSTANTE EN EL TIEMPO
             # ACTUALIZACION DE VERSION
             # HEADERS
             # MODULO DE ESCRITURA
             # METADATA
             import os
             import time
             import datetime
             import numpy
             import timeit
             from fractions import Fraction
             from time import time
             from time import sleep
             import schainpy.admin
             from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
             from schainpy.model.data.jrodata import Voltage
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             import pickle
             try:
                 import digital_rf
             except:
                 pass
             class DigitalRFReader(ProcessingUnit):
                 '''
                 classdocs
                 '''
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     ProcessingUnit.__init__(self)
                     self.dataOut                  = Voltage()
                     self.__printInfo              = True
                     self.__flagDiscontinuousBlock = False
                     self.__bufferIndex = 9999999
                     self.__codeType    = 0
                     self.__ippKm       = None
                     self.__nCode       = None
                     self.__nBaud       = None
                     self.__code        = None
                     self.dtype         = None
                     self.oldAverage    = None
                     self.path          = None
                 def close(self):
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     return
                 def __getCurrentSecond(self):
                     return self.__thisUnixSample / self.__sample_rate
                 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
                 def __setFileHeader(self):
                     '''
                     In this method will be initialized every parameter of dataOut object (header, no data)
                     '''
                     ippSeconds = 1.0 * self.__nSamples / self.__sample_rate
                     nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     try:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             self.__radarControllerHeader)
                     except:
                         self.dataOut.radarControllerHeaderObj = RadarControllerHeader(
                             txA=0,
                             txB=0,
                             nWindows=1,
                             nHeights=self.__nSamples,
                             firstHeight=self.__firstHeigth,
                             deltaHeight=self.__deltaHeigth,
                             codeType=self.__codeType,
                             nCode=self.__nCode, nBaud=self.__nBaud,
                             code=self.__code)
                     try:
                         self.dataOut.systemHeaderObj = SystemHeader(self.__systemHeader)
                     except:
                         self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
                                                                     nProfiles=nProfiles,
                                                                     nChannels=len(
                                                                         self.__channelList),
                                                                     adcResolution=14)
                     self.dataOut.type  = "Voltage"
                     self.dataOut.data  = None
                     self.dataOut.dtype = self.dtype
                     # self.dataOut.nChannels = 0
                     # self.dataOut.nHeights = 0
                     self.dataOut.nProfiles   = int(nProfiles)
                     self.dataOut.heightList  = self.__firstHeigth + \
                         numpy.arange(self.__nSamples, dtype=numpy.float) * \
                         self.__deltaHeigth
-                    self.dataOut.channelList = list(range(self.__num_subchannels))
+                    #self.dataOut.channelList = list(range(self.__num_subchannels))
+                    self.dataOut.channelList = list(range(len(self.__channelList)))
                     self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
                     # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData      = True
                     self.dataOut.flagDataAsBlock = False
                     # Set to TRUE if the data is discontinuous
                     self.dataOut.flagDiscontinuousBlock = False
                     self.dataOut.utctime     = None
                     # timezone like jroheader, difference in minutes between UTC and localtime
                     self.dataOut.timeZone    = self.__timezone / 60
                     self.dataOut.dstFlag     = 0
                     self.dataOut.errorCount  = 0
                     try:
                         self.dataOut.nCohInt = self.fixed_metadata_dict.get(
                             'nCohInt', self.nCohInt)
                         # asumo que la data esta decodificada
                         self.dataOut.flagDecodeData = self.fixed_metadata_dict.get(
                             'flagDecodeData', self.flagDecodeData)
                         # asumo que la data esta sin flip
                         self.dataOut.flagDeflipData = self.fixed_metadata_dict['flagDeflipData']
                         self.dataOut.flagShiftFFT   = self.fixed_metadata_dict['flagShiftFFT']
                         self.dataOut.useLocalTime   = self.fixed_metadata_dict['useLocalTime']
                     except:
                         pass
                     self.dataOut.ippSeconds = ippSeconds
                     # Time interval between profiles
                     # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency  = self.__frequency
                     self.dataOut.realtime   = self.__online
                 def findDatafiles(self, path, startDate=None, endDate=None):
                     if not os.path.isdir(path):
                         return []
                     try:
                         digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList    = digitalReadObj.get_channels()
                     if not channelNameList:
                         return []
                     metadata_dict      = digitalReadObj.get_rf_file_metadata(channelNameList[0])
                     sample_rate        = metadata_dict['sample_rate'][0]
                     this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
                     try:
                         timezone       = this_metadata_file['timezone'].value
                     except:
                         timezone       = 0
                     startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(
                         channelNameList[0]) / sample_rate - timezone
                     startDatetime      = datetime.datetime.utcfromtimestamp(startUTCSecond)
                     endDatatime        = datetime.datetime.utcfromtimestamp(endUTCSecond)
                     if not startDate:
                         startDate      = startDatetime.date()
                     if not endDate:
                         endDate        = endDatatime.date()
                     dateList           = []
                     thisDatetime       = startDatetime
                     while(thisDatetime <= endDatatime):
                         thisDate        = thisDatetime.date()
                         if thisDate     < startDate:
                             continue
                         if thisDate     > endDate:
                             break
                         dateList.append(thisDate)
                         thisDatetime += datetime.timedelta(1)
                     return dateList
                 def setup(self, path=None,
                           startDate=None,
                           endDate=None,
                           startTime=datetime.time(0, 0, 0),
                           endTime=datetime.time(23, 59, 59),
                           channelList=None,
                           nSamples=None,
                           online=False,
                           delay=60,
                           buffer_size=1024,
                           ippKm=None,
                           nCohInt=1,
                           nCode=1,
                           nBaud=1,
                           flagDecodeData=False,
                           code=numpy.ones((1, 1), dtype=numpy.int),
                           **kwargs):
                     '''
                     In this method we should set all initial parameters.
                     Inputs:
                         path
                         startDate
                         endDate
                         startTime
                         endTime
                         set
                         expLabel
                         ext
                         online
                         delay
                     '''
                     self.path           = path
                     self.nCohInt        = nCohInt
                     self.flagDecodeData = flagDecodeData
                     self.i              = 0
                     if not os.path.isdir(path):
                         raise ValueError("[Reading] Directory %s does not exist" % path)
                     try:
                         self.digitalReadObj = digital_rf.DigitalRFReader(
                             path, load_all_metadata=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(path)
                     channelNameList         = self.digitalReadObj.get_channels()
                     if not channelNameList:
                         raise ValueError("[Reading] Directory %s does not have any files" % path)
                     if not channelList:
                         channelList = list(range(len(channelNameList)))
                     ##########  Reading metadata ######################
                     top_properties           = self.digitalReadObj.get_properties(
                         channelNameList[channelList[0]])
                     self.__num_subchannels   = top_properties['num_subchannels']
                     self.__sample_rate       = 1.0 * \
                         top_properties['sample_rate_numerator'] / \
                         top_properties['sample_rate_denominator']
                     # self.__samples_per_file = top_properties['samples_per_file'][0]
                     self.__deltaHeigth       = 1e6 * 0.15 / self.__sample_rate  # why 0.15?
                     this_metadata_file       = self.digitalReadObj.get_digital_metadata(
                         channelNameList[channelList[0]])
                     metadata_bounds          = this_metadata_file.get_bounds()
                     self.fixed_metadata_dict = this_metadata_file.read(
                         metadata_bounds[0])[metadata_bounds[0]]  # GET FIRST HEADER
                     try:
                         self.__processingHeader      = self.fixed_metadata_dict['processingHeader']
                         self.__radarControllerHeader = self.fixed_metadata_dict['radarControllerHeader']
                         self.__systemHeader          = self.fixed_metadata_dict['systemHeader']
                         self.dtype                   = pickle.loads(self.fixed_metadata_dict['dtype'])
                     except:
                         pass
                     self.__frequency = None
                     self.__frequency = self.fixed_metadata_dict.get('frequency', 1)
                     self.__timezone = self.fixed_metadata_dict.get('timezone', 18000)
                     try:
                         nSamples = self.fixed_metadata_dict['nSamples']
                     except:
                         nSamples = None
                     self.__firstHeigth = 0
                     try:
                         codeType       = self.__radarControllerHeader['codeType']
                     except:
                         codeType       = 0
                     try:
                         if codeType:
                             nCode = self.__radarControllerHeader['nCode']
                             nBaud = self.__radarControllerHeader['nBaud']
                             code  = self.__radarControllerHeader['code']
                     except:
                         pass
                     if not ippKm:
                         try:
                             # seconds to km
                             ippKm = self.__radarControllerHeader['ipp']
                         except:
                             ippKm = None
                     ####################################################
                     self.__ippKm   = ippKm
                     startUTCSecond = None
                     endUTCSecond   = None
                     if startDate:
                         startDatetime  = datetime.datetime.combine(startDate, startTime)
                         startUTCSecond = (
                             startDatetime - datetime.datetime(1970, 1, 1)).total_seconds() + self.__timezone
                     if endDate:
                         endDatetime   = datetime.datetime.combine(endDate, endTime)
                         endUTCSecond  = (endDatetime - datetime.datetime(1970,
 , 1)).total_seconds() + self.__timezone
+                    print(startUTCSecond,endUTCSecond)
                     start_index, end_index = self.digitalReadObj.get_bounds(
                         channelNameList[channelList[0]])
+                    print("*****",start_index,end_index)
                     if not startUTCSecond:
                         startUTCSecond = start_index / self.__sample_rate
                     if start_index     > startUTCSecond * self.__sample_rate:
                         startUTCSecond = start_index / self.__sample_rate
                     if not endUTCSecond:
                         endUTCSecond   = end_index / self.__sample_rate
                     if end_index       < endUTCSecond * self.__sample_rate:
                         endUTCSecond   = end_index / self.__sample_rate
                     if not nSamples:
                         if not ippKm:
                             raise ValueError("[Reading] nSamples or ippKm should be defined")
                         nSamples            = int(ippKm / (1e6 * 0.15 / self.__sample_rate))
                     channelBoundList        = []
                     channelNameListFiltered = []
                     for thisIndexChannel in channelList:
                         thisChannelName        = channelNameList[thisIndexChannel]
                         start_index, end_index = self.digitalReadObj.get_bounds(
                             thisChannelName)
                         channelBoundList.append((start_index, end_index))
                         channelNameListFiltered.append(thisChannelName)
                     self.profileIndex = 0
                     self.i            = 0
                     self.__delay      = delay
                     self.__codeType   = codeType
                     self.__nCode      = nCode
                     self.__nBaud      = nBaud
                     self.__code       = code
                     self.__datapath         = path
                     self.__online           = online
                     self.__channelList      = channelList
                     self.__channelNameList  = channelNameListFiltered
                     self.__channelBoundList = channelBoundList
                     self.__nSamples         = nSamples
                     self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
                     self.__nChannels        = len(self.__channelList)
                     self.__startUTCSecond   = startUTCSecond
                     self.__endUTCSecond     = endUTCSecond
                     self.__timeInterval     = 1.0 * self.__samples_to_read / \
                         self.__sample_rate  # Time interval
                     if online:
                         # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
                         startUTCSecond = numpy.floor(endUTCSecond)
                     # por que en el otro metodo lo primero q se hace es sumar samplestoread
                     self.__thisUnixSample = int(startUTCSecond * self.__sample_rate) - self.__samples_to_read
-                    self.__data_buffer    = numpy.zeros(
+                    #self.__data_buffer    = numpy.zeros(
-                        (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
+                    #    (self.__num_subchannels, self.__samples_to_read), dtype=numpy.complex)
+                    self.__data_buffer    = numpy.zeros((int(len(channelList)), self.__samples_to_read), dtype=numpy.complex)
                     self.__setFileHeader()
                     self.isConfig = True
                     print("[Reading] Digital RF Data was found from %s to %s " % (
                         datetime.datetime.utcfromtimestamp(
                             self.__startUTCSecond - self.__timezone),
                         datetime.datetime.utcfromtimestamp(
                             self.__endUTCSecond - self.__timezone)
                     ))
                     print("[Reading] Starting process from %s to %s" % (datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
                                                                         datetime.datetime.utcfromtimestamp(
                         endUTCSecond - self.__timezone)
                     ))
                     self.oldAverage    = None
                     self.count         = 0
                     self.executionTime = 0
                 def __reload(self):
                     #         print
                     #         print "%s not in range [%s, %s]" %(
                     #                                           datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
                     #                                           datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
                     #                                           )
                     print("[Reading] reloading metadata ...")
                     try:
                         self.digitalReadObj.reload(complete_update=True)
                     except:
                         self.digitalReadObj = digital_rf.DigitalRFReader(self.path)
                     start_index, end_index  = self.digitalReadObj.get_bounds(
                         self.__channelNameList[self.__channelList[0]])
                     if start_index          > self.__startUTCSecond * self.__sample_rate:
                         self.__startUTCSecond = 1.0 * start_index / self.__sample_rate
                     if end_index            > self.__endUTCSecond * self.__sample_rate:
                         self.__endUTCSecond = 1.0 * end_index / self.__sample_rate
                         print()
                         print("[Reading] New timerange found [%s, %s] " % (
                             datetime.datetime.utcfromtimestamp(
                                 self.__startUTCSecond - self.__timezone),
                             datetime.datetime.utcfromtimestamp(
                                 self.__endUTCSecond - self.__timezone)
                         ))
                         return True
                     return False
                 def timeit(self, toExecute):
                     t0                  = time.time()
                     toExecute()
                     self.executionTime  = time.time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage     = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count          = self.count + 1.0
                     return
                 def __readNextBlock(self, seconds=30, volt_scale=1):
                     '''
                     '''
                     # Set the next data
                     self.__flagDiscontinuousBlock = False
                     self.__thisUnixSample        += self.__samples_to_read
                     if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                         print ("[Reading] There are no more data into selected time-range")
                         if self.__online:
                             sleep(3)
                             self.__reload()
                         else:
                             return False
                         if self.__thisUnixSample + 2 * self.__samples_to_read > self.__endUTCSecond * self.__sample_rate:
                             return False
                             self.__thisUnixSample -= self.__samples_to_read
                     indexChannel = 0
                     dataOk = False
                     for thisChannelName in self.__channelNameList:  # TODO VARIOS CHANNELS?
                         for indexSubchannel in range(self.__num_subchannels):
                             try:
                                 t0     = time()
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                                 self.executionTime  = time() - t0
                                 if self.oldAverage is None:
                                     self.oldAverage = self.executionTime
                                 self.oldAverage     = (
                                     self.executionTime + self.count * self.oldAverage) / (self.count + 1.0)
                                 self.count = self.count + 1.0
                             except IOError as e:
                                 # read next profile
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s" % datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone), e)
                                 break
                             if result.shape[0] != self.__samples_to_read:
                                 self.__flagDiscontinuousBlock = True
                                 print("[Reading] %s: Too few samples were found, just %d/%d  samples" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                                                          result.shape[0],
                                                                                                          self.__samples_to_read))
                                 break
-                            self.__data_buffer[indexSubchannel, :] = result * volt_scale
+                            self.__data_buffer[indexChannel, :] = result * volt_scale
                             indexChannel+=1
                             dataOk       = True
                     self.__utctime       = self.__thisUnixSample / self.__sample_rate
                     if not dataOk:
                         return False
                     print("[Reading] %s: %d samples <> %f sec" % (datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
                                                                   self.__samples_to_read,
                                                                   self.__timeInterval))
                     self.__bufferIndex   = 0
                     return True
                 def __isBufferEmpty(self):
                     return self.__bufferIndex > self.__samples_to_read - self.__nSamples  # 40960 - 40
                 def getData(self, seconds=30, nTries=5):
                     '''
                         This method gets the data from files and put the data into the dataOut object
                         In addition, increase el the buffer counter in one.
                         Return:
                             data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                         buffer. Si no hay mas archivos a leer retorna None.
                         Affected:
                             self.dataOut
                             self.profileIndex
                             self.flagDiscontinuousBlock
                             self.flagIsNewBlock
                     '''
                     #print("getdata")
                     err_counter = 0
                     self.dataOut.flagNoData = True
                     if self.__isBufferEmpty():
                         #print("hi")
                         self.__flagDiscontinuousBlock = False
                         while True:
                             #print ("q ha pasado")
                             if self.__readNextBlock():
                                 break
                             if self.__thisUnixSample > self.__endUTCSecond * self.__sample_rate:
                                 raise schainpy.admin.SchainError('Error')
                                 return
                             if self.__flagDiscontinuousBlock:
                                 raise schainpy.admin.SchainError('discontinuous block found')
                                 return
                             if not self.__online:
                                 raise schainpy.admin.SchainError('Online?')
                                 return
                             err_counter += 1
                             if err_counter > nTries:
                                 raise schainpy.admin.SchainError('Max retrys reach')
                                 return
                             print('[Reading] waiting %d seconds to read a new block' % seconds)
-                            time.sleep(seconds)
+                            sleep(seconds)
                     self.dataOut.data                   = self.__data_buffer[:, self.__bufferIndex:self.__bufferIndex + self.__nSamples]
                     self.dataOut.utctime                = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                     self.dataOut.flagNoData             = False
                     self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                     self.dataOut.profileIndex           = self.profileIndex
                     self.__bufferIndex += self.__nSamples
                     self.profileIndex  += 1
                     if self.profileIndex == self.dataOut.nProfiles:
                         self.profileIndex = 0
                     return True
                 def printInfo(self):
                     '''
                     '''
                     if self.__printInfo == False:
                         return
                     # self.systemHeaderObj.printInfo()
                     # self.radarControllerHeaderObj.printInfo()
                     self.__printInfo = False
                 def printNumberOfBlock(self):
                     '''
                     '''
                     return
                     # print self.profileIndex
                 def run(self, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     '''
                     if not self.isConfig:
                         self.setup(**kwargs)
                     #self.i = self.i+1
                     self.getData(seconds=self.__delay)
                     return
             @MPDecorator
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
                     self.dataOut       = None
                     self.dtype         = None
                     self.oldAverage    = 0
                 def setHeader(self):
                     self.metadata_dict['frequency']      = self.dataOut.frequency
                     self.metadata_dict['timezone']       = self.dataOut.timeZone
                     self.metadata_dict['dtype']          = pickle.dumps(self.dataOut.dtype)
                     self.metadata_dict['nProfiles']      = self.dataOut.nProfiles
                     self.metadata_dict['heightList']     = self.dataOut.heightList
                     self.metadata_dict['channelList']    = self.dataOut.channelList
                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
                     self.metadata_dict['flagShiftFFT']   = self.dataOut.flagShiftFFT
                     self.metadata_dict['useLocalTime']   = self.dataOut.useLocalTime
                     self.metadata_dict['nCohInt']        = self.dataOut.nCohInt
                     self.metadata_dict['type']           = self.dataOut.type
                     self.metadata_dict['flagDataAsBlock']= getattr(
                         self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
                     self.__ippSeconds  = dataOut.ippSeconds
                     self.__deltaH      = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
                     self.__dtype       = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         self.__dtype = dataOut.dtype[0]
                     self.__nSamples  = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     else:
                         self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     file_cadence_millisecs  = 1000
                     sample_rate_fraction    = Fraction(self.__sample_rate).limit_denominator()
                     sample_rate_numerator   = int(sample_rate_fraction.numerator)
                     sample_rate_denominator = int(sample_rate_fraction.denominator)
                     start_global_index      = dataOut.utctime * self.__sample_rate
                     uuid              = 'prueba'
                     compression_level = 0
                     checksum          = False
                     is_complex        = True
                     num_subchannels   = len(dataOut.channelList)
                     is_continuous     = True
                     marching_periods  = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
                     metadata_dir         = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
                     self.isConfig      = True
                     self.currentSample = 0
                     self.oldAverage    = 0
                     self.count         = 0
                     return
                 def writeMetadata(self):
                     start_idx                                   = self.__sample_rate * self.dataOut.utctime
                     self.metadata_dict['processingHeader']      = self.dataOut.processingHeaderObj.getAsDict(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
                     self.metadata_dict['systemHeader']          = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
                     self.executionTime  = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage     = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count          = self.count + 1.0
                     return
                 def writeData(self):
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         for channel in self.dataOut.channelList:
                             for i in range(self.dataOut.nFFTPoints):
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['i'] = self.dataOut.data[channel][i].imag
                     else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                             for channel in self.dataOut.channelList:
                                 self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
                     def f(): return self.digitalWriteObj.rf_write(self.arr_data)
                     self.timeit(f)
                     return
                 def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=1000, dirCadence=36000, metadataCadence=1, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataOut: object with the data
                     '''
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(dataOut, path, frequency, fileCadence,
                                    dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
                     ## self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                     return dataOut# en la version 2.7 no aparece este return
                 def close(self):
                     print('[Writing] - Closing files ')
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     try:
                         self.digitalWriteObj.close()
                     except:
                         pass

schainpy/model/proc/jroproc_heispectra.py +4 0

             import numpy
             from .jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import SpectraHeis
             from schainpy.utils import log
             class SpectraHeisProc(ProcessingUnit):
                 def __init__(self):#, **kwargs):
                     ProcessingUnit.__init__(self)#, **kwargs)
             #        self.buffer = None
             #        self.firstdatatime = None
             #        self.profIndex = 0
                     self.dataOut = SpectraHeis()
                 def __updateObjFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
             #        self.dataOut.dtype = self.dataIn.dtype
                     self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
             #        self.dataOut.nHeights = self.dataIn.nHeights
             #        self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
             #        self.dataOut.nProfiles = 1
                     self.dataOut.ippFactor = 1
                     self.dataOut.noise_estimation = None
             #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.nFFTPoints = self.dataIn.nHeights
             #        self.dataOut.channelIndexList = self.dataIn.channelIndexList
             #        self.dataOut.flagNoData = self.dataIn.flagNoData
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.dataIn.utctime
             #        self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
             #        self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
             #         self.dataOut.ippSeconds= self.dataIn.ippSeconds
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
             #         self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
             #        self.dataOut.set=self.dataIn.set
             #        self.dataOut.deltaHeight=self.dataIn.deltaHeight
                 def __updateObjFromFits(self):
                     self.dataOut.utctime = self.dataIn.utctime
             #         self.dataOut.channelIndexList = self.dataIn.channelIndexList
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.data_spc = self.dataIn.data
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = self.dataIn.nIncohInt
             #         self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.useLocalTime = True
             #         self.dataOut.
             #         self.dataOut.
                 def __getFft(self):
                     fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
                     self.dataOut.data_spc = spc
                 def run(self):
                     self.dataOut.flagNoData = True
                     if self.dataIn.type == "Fits":
                         self.__updateObjFromFits()
                         self.dataOut.flagNoData = False
                         return
                     if self.dataIn.type == "SpectraHeis":
                         self.dataOut.copy(self.dataIn)
                         return
                     if self.dataIn.type == "Voltage":
                         self.__updateObjFromVoltage()
                         self.__getFft()
                         self.dataOut.flagNoData = False
                         return
                     raise ValueError("The type object %s is not valid"%(self.dataIn.type))
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     return 1
             class IncohInt4SpectraHeis(Operation):
                 isConfig = False
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 n = None
                 def __init__(self):#, **kwargs):
                     Operation.__init__(self)#, **kwargs)
             #         self.isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if n == None and timeInterval == None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
             #         n = None
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
+                    #if self.__profIndex == 0:
+                    #    self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata is None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def run(self, dataOut, n=None, timeInterval=None, overlapping=False, **kwargs):
                     if not self.isConfig:
                         self.setup(n=n, timeInterval=timeInterval, overlapping=overlapping)
                         self.isConfig = True
+                    #print("utc_time",dataOut.utctime)
                     avgdata, avgdatatime = self.integrate(dataOut.data_spc, dataOut.utctime)
             #        dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data_spc = avgdata
                         dataOut.nIncohInt *= self.n
             #            dataOut.nCohInt *= self.n
                         dataOut.utctime = avgdatatime
             #             dataOut.timeInterval = dataOut.ippSeconds * dataOut.nIncohInt
             #            dataOut.timeInterval = self.__timeInterval*self.n
                         dataOut.flagNoData = False
                     return dataOut

schainpy/model/proc/jroproc_parameters.py 0 0

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

schainpy/model/proc/jroproc_voltage.py +3 -1

             import sys
             import numpy,math
             from scipy import interpolate
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.data.jrodata import Voltage,hildebrand_sekhon
             from schainpy.utils import log
             from time import time
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Voltage()
                     self.flip = 1
                     self.setupReq = False
                 def run(self):
                     if self.dataIn.type == 'AMISR':
                         self.__updateObjFromAmisrInput()
                     if self.dataIn.type == 'Voltage':
                         self.dataOut.copy(self.dataIn)
                 def __updateObjFromAmisrInput(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.flagNoData = self.dataIn.flagNoData
                     self.dataOut.data = self.dataIn.data
                     self.dataOut.utctime = self.dataIn.utctime
                     self.dataOut.channelList = self.dataIn.channelList
                     #self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.nProfiles = self.dataIn.nProfiles
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.frequency = self.dataIn.frequency
                     self.dataOut.azimuth = self.dataIn.azimuth
                     self.dataOut.zenith = self.dataIn.zenith
                     self.dataOut.beam.codeList = self.dataIn.beam.codeList
                     self.dataOut.beam.azimuthList = self.dataIn.beam.azimuthList
                     self.dataOut.beam.zenithList = self.dataIn.beam.zenithList
             class selectChannels(Operation):
                 def run(self, dataOut, channelList):
                     channelIndexList = []
                     self.dataOut = dataOut
                     for channel in channelList:
                         if channel not in self.dataOut.channelList:
                             raise ValueError("Channel %d is not in %s" %(channel, str(self.dataOut.channelList)))
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                     return self.dataOut
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             raise ValueError("The value %d in channelIndexList is not valid" %channelIndex)
                     if self.dataOut.type == 'Voltage':
                         if self.dataOut.flagDataAsBlock:
                             """
                             Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                             """
                             data = self.dataOut.data[channelIndexList,:,:]
                         else:
                             data = self.dataOut.data[channelIndexList,:]
                         self.dataOut.data = data
                         # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                         self.dataOut.channelList = range(len(channelIndexList))
                     elif self.dataOut.type == 'Spectra':
                         data_spc = self.dataOut.data_spc[channelIndexList, :]
                         data_dc = self.dataOut.data_dc[channelIndexList, :]
                         self.dataOut.data_spc = data_spc
                         self.dataOut.data_dc = data_dc
                         # self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                         self.dataOut.channelList = range(len(channelIndexList))
                         self.__selectPairsByChannel(channelIndexList)
                     return 1
                 def __selectPairsByChannel(self, channelList=None):
                     if channelList == None:
                         return
                     pairsIndexListSelected = []
                     for pairIndex in self.dataOut.pairsIndexList:
                         # First pair
                         if self.dataOut.pairsList[pairIndex][0] not in channelList:
                             continue
                         # Second pair
                         if self.dataOut.pairsList[pairIndex][1] not in channelList:
                             continue
                         pairsIndexListSelected.append(pairIndex)
                     if not pairsIndexListSelected:
                         self.dataOut.data_cspc = None
                         self.dataOut.pairsList = []
                         return
                     self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
                     self.dataOut.pairsList = [self.dataOut.pairsList[i]
                                               for i in pairsIndexListSelected]
                     return
             class selectHeights(Operation):
                 def run(self, dataOut, minHei=None, maxHei=None, minIndex=None, maxIndex=None):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     self.dataOut = dataOut
                     if minHei and maxHei:
                         if (minHei < self.dataOut.heightList[0]):
                             minHei = self.dataOut.heightList[0]
                         if (maxHei > self.dataOut.heightList[-1]):
                             maxHei = self.dataOut.heightList[-1]
                         minIndex = 0
                         maxIndex = 0
                         heights = self.dataOut.heightList
                         inda = numpy.where(heights >= minHei)
                         indb = numpy.where(heights <= maxHei)
                         try:
                             minIndex = inda[0][0]
                         except:
                             minIndex = 0
                         try:
                             maxIndex = indb[0][-1]
                         except:
                             maxIndex = len(heights)
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return self.dataOut
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOut.data
                         self.dataOut.heightList
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOut.type == 'Voltage':
                         if (minIndex < 0) or (minIndex > maxIndex):
                             raise ValueError("Height index range (%d,%d) is not valid" % (minIndex, maxIndex))
                         if (maxIndex >= self.dataOut.nHeights):
                             maxIndex = self.dataOut.nHeights
                         #voltage
                         if self.dataOut.flagDataAsBlock:
                             """
                             Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                             """
                             data = self.dataOut.data[:,:, minIndex:maxIndex]
                         else:
                             data = self.dataOut.data[:, minIndex:maxIndex]
                         #         firstHeight = self.dataOut.heightList[minIndex]
                         self.dataOut.data = data
                         self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex]
                         if self.dataOut.nHeights <= 1:
                             raise ValueError("selectHeights: Too few heights. Current number of heights is %d" %(self.dataOut.nHeights))
                     elif self.dataOut.type == 'Spectra':
                         if (minIndex < 0) or (minIndex > maxIndex):
                             raise ValueError("Error selecting heights: Index range (%d,%d) is not valid" % (
                                 minIndex, maxIndex))
                         if (maxIndex >= self.dataOut.nHeights):
                             maxIndex = self.dataOut.nHeights - 1
                         # Spectra
                         data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
                         data_cspc = None
                         if self.dataOut.data_cspc is not None:
                             data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
                         data_dc = None
                         if self.dataOut.data_dc is not None:
                             data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
                         self.dataOut.data_spc = data_spc
                         self.dataOut.data_cspc = data_cspc
                         self.dataOut.data_dc = data_dc
                         self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
                     return 1
             class filterByHeights(Operation):
                 def run(self, dataOut, window):
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     if window == None:
                         window = (dataOut.radarControllerHeaderObj.txA/dataOut.radarControllerHeaderObj.nBaud) / deltaHeight
                     newdelta = deltaHeight * window
                     r = dataOut.nHeights % window
                     newheights = (dataOut.nHeights-r)/window
                     if newheights <= 1:
                         raise ValueError("filterByHeights: Too few heights. Current number of heights is %d and window is %d" %(dataOut.nHeights, window))
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es obtenida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         buffer = dataOut.data[:, :, 0:int(dataOut.nHeights-r)]
                         buffer = buffer.reshape(dataOut.nChannels, dataOut.nProfiles, int(dataOut.nHeights/window), window)
                         buffer = numpy.sum(buffer,3)
                     else:
                         buffer = dataOut.data[:,0:int(dataOut.nHeights-r)]
                         buffer = buffer.reshape(dataOut.nChannels,int(dataOut.nHeights/window),int(window))
                         buffer = numpy.sum(buffer,2)
                     dataOut.data = buffer
                     dataOut.heightList = dataOut.heightList[0] + numpy.arange( newheights )*newdelta
                     dataOut.windowOfFilter = window
                     return dataOut
             class setH0(Operation):
                 def run(self, dataOut, h0, deltaHeight = None):
                     if not deltaHeight:
                         deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     nHeights = dataOut.nHeights
                     newHeiRange = h0 + numpy.arange(nHeights)*deltaHeight
                     dataOut.heightList = newHeiRange
                     return dataOut
             class deFlip(Operation):
                 def run(self, dataOut, channelList = []):
                     data = dataOut.data.copy()
                     if dataOut.flagDataAsBlock:
                         flip = self.flip
                         profileList = list(range(dataOut.nProfiles))
                         if not channelList:
                             for thisProfile in profileList:
                                 data[:,thisProfile,:] = data[:,thisProfile,:]*flip
                                 flip *= -1.0
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in dataOut.channelList:
                                     continue
                                 for thisProfile in profileList:
                                     data[thisChannel,thisProfile,:] = data[thisChannel,thisProfile,:]*flip
                                     flip *= -1.0
                         self.flip = flip
                     else:
                         if not channelList:
                             data[:,:] = data[:,:]*self.flip
                         else:
                             for thisChannel in channelList:
                                 if thisChannel not in dataOut.channelList:
                                     continue
                                 data[thisChannel,:] = data[thisChannel,:]*self.flip
                         self.flip *= -1.
                     dataOut.data = data
                     return dataOut
             class setAttribute(Operation):
                 '''
                 Set an arbitrary attribute(s) to dataOut
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                     self._ready = False
                 def run(self, dataOut, **kwargs):
                     for key, value in kwargs.items():
                         setattr(dataOut, key, value)
                     return dataOut
             @MPDecorator
             class printAttribute(Operation):
                 '''
                 Print an arbitrary attribute of dataOut
                 '''
                 def __init__(self):
                     Operation.__init__(self)
                 def run(self, dataOut, attributes):
                     if isinstance(attributes, str):
                         attributes = [attributes]
                     for attr in attributes:
                         if hasattr(dataOut, attr):
                             log.log(getattr(dataOut, attr), attr)
             class interpolateHeights(Operation):
                 def run(self, dataOut, topLim, botLim):
                     #69 al 72 para julia
                     #82-84 para meteoros
                     if len(numpy.shape(dataOut.data))==2:
                         sampInterp = (dataOut.data[:,botLim-1] + dataOut.data[:,topLim+1])/2
                         sampInterp = numpy.transpose(numpy.tile(sampInterp,(topLim-botLim + 1,1)))
                         #dataOut.data[:,botLim:limSup+1] = sampInterp
                         dataOut.data[:,botLim:topLim+1] = sampInterp
                     else:
                         nHeights = dataOut.data.shape[2]
                         x = numpy.hstack((numpy.arange(botLim),numpy.arange(topLim+1,nHeights)))
                         y = dataOut.data[:,:,list(range(botLim))+list(range(topLim+1,nHeights))]
                         f = interpolate.interp1d(x, y, axis = 2)
                         xnew = numpy.arange(botLim,topLim+1)
                         ynew = f(xnew)
                         dataOut.data[:,:,botLim:topLim+1]  = ynew
                     return dataOut
             class CohInt(Operation):
                 isConfig = False
                 __profIndex = 0
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __bufferStride = []
                 __dataReady = False
                 __profIndexStride = 0
                 __dataToPutStride = False
                 n = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def setup(self, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n               :    Number of coherent integrations
                         timeInterval    :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping     :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     self.byblock = byblock
                     self.stride = stride
                     if n == None and timeInterval == None:
                         raise ValueError("n or timeInterval should be specified ...")
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverlapping = True
                         self.__buffer = None
                     else:
                         self.__withOverlapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverlapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverlapping:
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     # print data
                     # raise
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
                     #         n = None
                     # print data
                     # raise
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrateByStride(self, data, datatime):
                     # print data
                     if self.__profIndex == 0:
                         self.__buffer = [[data.copy(), datatime]]
                     else:
                         self.__buffer.append([data.copy(),datatime])
                     self.__profIndex += 1
                     self.__dataReady = False
                     if self.__profIndex == self.n * self.stride :
                         self.__dataToPutStride = True
                         self.__profIndexStride = 0
                         self.__profIndex = 0
                         self.__bufferStride = []
                         for i in range(self.stride):
                             current = self.__buffer[i::self.stride]
                             data = numpy.sum([t[0] for t in current], axis=0)
                             avgdatatime = numpy.average([t[1] for t in current])
                             # print data
                             self.__bufferStride.append((data, avgdatatime))
                     if self.__dataToPutStride:
                         self.__dataReady = True
                         self.__profIndexStride += 1
                         if self.__profIndexStride == self.stride:
                             self.__dataToPutStride = False
                         # print self.__bufferStride[self.__profIndexStride - 1]
                         # raise
                         return self.__bufferStride[self.__profIndexStride - 1]
                     return None, None
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata is None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime - self.__lastdatatime
                     if not self.__withOverlapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def integrateByBlock(self, dataOut):
                     times = int(dataOut.data.shape[1]/self.n)
                     avgdata = numpy.zeros((dataOut.nChannels, times, dataOut.nHeights), dtype=numpy.complex)
                     id_min = 0
                     id_max = self.n
                     for i in range(times):
                         junk = dataOut.data[:,id_min:id_max,:]
                         avgdata[:,i,:] = junk.sum(axis=1)
                         id_min += self.n
                         id_max += self.n
                     timeInterval = dataOut.ippSeconds*self.n
                     avgdatatime = (times - 1) * timeInterval + dataOut.utctime
                     self.__dataReady = True
                     return avgdata, avgdatatime
                 def run(self, dataOut, n=None, timeInterval=None, stride=None, overlapping=False, byblock=False, **kwargs):
                     if not self.isConfig:
                         self.setup(n=n, stride=stride, timeInterval=timeInterval, overlapping=overlapping, byblock=byblock, **kwargs)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         """
                         Si la data es leida por bloques, dimension = [nChannels, nProfiles, nHeis]
                         """
                         avgdata, avgdatatime = self.integrateByBlock(dataOut)
                         dataOut.nProfiles /= self.n
                     else:
                         if stride is None:
                             avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
                         else:
                             avgdata, avgdatatime = self.integrateByStride(dataOut.data, dataOut.utctime)
                     #   dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         if not dataOut.flagCohInt:
                             dataOut.nCohInt *= self.n
                             dataOut.flagCohInt = True
                         dataOut.utctime = avgdatatime
                         # print avgdata, avgdatatime
                         # raise
                         #   dataOut.timeInterval = dataOut.ippSeconds * dataOut.nCohInt
                         dataOut.flagNoData = False
                     return dataOut
             class Decoder(Operation):
                 isConfig = False
                 __profIndex = 0
                 code = None
                 nCode = None
                 nBaud = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.times = None
                     self.osamp = None
                 #         self.__setValues = False
                     self.isConfig = False
                     self.setupReq = False
                 def setup(self, code, osamp, dataOut):
                     self.__profIndex = 0
                     self.code = code
                     self.nCode = len(code)
                     self.nBaud = len(code[0])
                     if (osamp != None) and (osamp >1):
                         self.osamp = osamp
                         self.code = numpy.repeat(code, repeats=self.osamp, axis=1)
                         self.nBaud = self.nBaud*self.osamp
                     self.__nChannels = dataOut.nChannels
                     self.__nProfiles = dataOut.nProfiles
                     self.__nHeis = dataOut.nHeights
                     if self.__nHeis < self.nBaud:
                         raise ValueError('Number of heights (%d) should be greater than number of bauds (%d)' %(self.__nHeis, self.nBaud))
                     #Frequency
                     __codeBuffer = numpy.zeros((self.nCode, self.__nHeis), dtype=numpy.complex)
                     __codeBuffer[:,0:self.nBaud] = self.code
                     self.fft_code = numpy.conj(numpy.fft.fft(__codeBuffer, axis=1))
                     if dataOut.flagDataAsBlock:
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.__nProfiles, self.ndatadec), dtype=numpy.complex)
                     else:
                         #Time
                         self.ndatadec = self.__nHeis #- self.nBaud + 1
                         self.datadecTime = numpy.zeros((self.__nChannels, self.ndatadec), dtype=numpy.complex)
                 def __convolutionInFreq(self, data):
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=1)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=1)
                     return data
                 def __convolutionInFreqOpt(self, data):
                     raise NotImplementedError
                 def __convolutionInTime(self, data):
                     code = self.code[self.__profIndex]
                     for i in range(self.__nChannels):
                         self.datadecTime[i,:] = numpy.correlate(data[i,:], code, mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInTime(self, data):
                     repetitions = int(self.__nProfiles / self.nCode)
                     junk = numpy.lib.stride_tricks.as_strided(self.code, (repetitions, self.code.size), (0, self.code.itemsize))
                     junk = junk.flatten()
                     code_block = numpy.reshape(junk, (self.nCode*repetitions, self.nBaud))
                     profilesList = range(self.__nProfiles)
                     for i in range(self.__nChannels):
                         for j in profilesList:
                             self.datadecTime[i,j,:] = numpy.correlate(data[i,j,:], code_block[j,:], mode='full')[self.nBaud-1:]
                     return self.datadecTime
                 def __convolutionByBlockInFreq(self, data):
                     raise NotImplementedError("Decoder by frequency fro Blocks not implemented")
                     fft_code = self.fft_code[self.__profIndex].reshape(1,-1)
                     fft_data = numpy.fft.fft(data, axis=2)
                     conv = fft_data*fft_code
                     data = numpy.fft.ifft(conv,axis=2)
                     return data
                 def run(self, dataOut, code=None, nCode=None, nBaud=None, mode = 0, osamp=None, times=None):
                     if dataOut.flagDecodeData:
                         print("This data is already decoded, recoding again ...")
                     if not self.isConfig:
                         if code is None:
                             if dataOut.code is None:
                                 raise ValueError("Code could not be read from %s instance. Enter a value in Code parameter" %dataOut.type)
                             code = dataOut.code
                         else:
                             code = numpy.array(code).reshape(nCode,nBaud)
                         self.setup(code, osamp, dataOut)
                         self.isConfig = True
                         if mode == 3:
                             sys.stderr.write("Decoder Warning: mode=%d is not valid, using mode=0\n" %mode)
                         if times != None:
                             sys.stderr.write("Decoder Warning: Argument 'times' in not used anymore\n")
                     if self.code is None:
                         print("Fail decoding: Code is not defined.")
                         return
                     self.__nProfiles = dataOut.nProfiles
                     datadec = None
                     if mode == 3:
                         mode = 0
                     if dataOut.flagDataAsBlock:
                         """
                         Decoding when data have been read as block,
                         """
                         if mode == 0:
                             datadec = self.__convolutionByBlockInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionByBlockInFreq(dataOut.data)
                     else:
                         """
                         Decoding when data have been read profile by profile
                         """
                         if mode == 0:
                             datadec = self.__convolutionInTime(dataOut.data)
                         if mode == 1:
                             datadec = self.__convolutionInFreq(dataOut.data)
                         if mode == 2:
                             datadec = self.__convolutionInFreqOpt(dataOut.data)
                     if datadec is None:
                         raise ValueError("Codification mode selected is not valid: mode=%d. Try selecting 0 or 1" %mode)
                     dataOut.code = self.code
                     dataOut.nCode = self.nCode
                     dataOut.nBaud = self.nBaud
                     dataOut.data = datadec
                     dataOut.heightList = dataOut.heightList[0:datadec.shape[-1]]
                     dataOut.flagDecodeData = True #asumo q la data esta decodificada
                     if self.__profIndex == self.nCode-1:
                         self.__profIndex = 0
                         return dataOut
                     self.__profIndex += 1
                     return dataOut
                 #        dataOut.flagDeflipData = True #asumo q la data no esta sin flip
             class ProfileConcat(Operation):
                 isConfig = False
                 buffer = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def reset(self):
                     self.buffer = numpy.zeros_like(self.buffer)
                     self.start_index = 0
                     self.times = 1
                 def setup(self, data, m, n=1):
                     self.buffer = numpy.zeros((data.shape[0],data.shape[1]*m),dtype=type(data[0,0]))
                     self.nHeights = data.shape[1]#.nHeights
                     self.start_index = 0
                     self.times = 1
                 def concat(self, data):
                     self.buffer[:,self.start_index:self.nHeights*self.times] = data.copy()
                     self.start_index = self.start_index + self.nHeights
                 def run(self, dataOut, m):
                     dataOut.flagNoData = True
                     if not self.isConfig:
                         self.setup(dataOut.data, m, 1)
                         self.isConfig = True
                     if dataOut.flagDataAsBlock:
                         raise ValueError("ProfileConcat can only be used when voltage have been read profile by profile, getBlock = False")
                     else:
                         self.concat(dataOut.data)
                         self.times += 1
                         if self.times > m:
                             dataOut.data = self.buffer
                             self.reset()
                             dataOut.flagNoData = False
                             # se deben actualizar mas propiedades del header y del objeto dataOut, por ejemplo, las alturas
                             deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                             xf = dataOut.heightList[0] + dataOut.nHeights * deltaHeight * m
                             dataOut.heightList = numpy.arange(dataOut.heightList[0], xf, deltaHeight)
                             dataOut.ippSeconds *= m
                     return dataOut
             class ProfileSelector(Operation):
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.profileIndex = 0
                 def incProfileIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isThisProfileInRange(self, profileIndex, minIndex, maxIndex):
                     if profileIndex < minIndex:
                         return False
                     if profileIndex > maxIndex:
                         return False
                     return True
                 def isThisProfileInList(self, profileIndex, profileList):
                     if profileIndex not in profileList:
                         return False
                     return True
                 def run(self, dataOut, profileList=None, profileRangeList=None, beam=None, byblock=False, rangeList = None, nProfiles=None):
                     """
                     ProfileSelector:
                     Inputs:
                         profileList        :    Index of profiles selected. Example: profileList = (0,1,2,7,8)
                         profileRangeList    :    Minimum and maximum profile indexes. Example: profileRangeList = (4, 30)
                         rangeList            :    List of profile ranges. Example: rangeList = ((4, 30), (32, 64), (128, 256))
                     """
                     if rangeList is not None:
                         if type(rangeList[0]) not in (tuple, list):
                             rangeList = [rangeList]
                     dataOut.flagNoData = True
                     if dataOut.flagDataAsBlock:
                         """
                         data dimension  = [nChannels, nProfiles, nHeis]
                         """
                         if profileList != None:
                             dataOut.data = dataOut.data[:,profileList,:]
                         if profileRangeList != None:
                             minIndex = profileRangeList[0]
                             maxIndex = profileRangeList[1]
                             profileList = list(range(minIndex, maxIndex+1))
                             dataOut.data = dataOut.data[:,minIndex:maxIndex+1,:]
                         if rangeList != None:
                             profileList = []
                             for thisRange in rangeList:
                                 minIndex = thisRange[0]
                                 maxIndex = thisRange[1]
                                 profileList.extend(list(range(minIndex, maxIndex+1)))
                             dataOut.data = dataOut.data[:,profileList,:]
                         dataOut.nProfiles = len(profileList)
                         dataOut.profileIndex = dataOut.nProfiles - 1
                         dataOut.flagNoData = False
                         return dataOut
                     """
                     data dimension  = [nChannels, nHeis]
                     """
                     if profileList != None:
                         if self.isThisProfileInList(dataOut.profileIndex, profileList):
                             self.nProfiles = len(profileList)
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if profileRangeList != None:
                         minIndex = profileRangeList[0]
                         maxIndex = profileRangeList[1]
                         if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                             self.nProfiles = maxIndex - minIndex + 1
                             dataOut.nProfiles = self.nProfiles
                             dataOut.profileIndex = self.profileIndex
                             dataOut.flagNoData = False
                             self.incProfileIndex()
                         return dataOut
                     if rangeList != None:
                         nProfiles = 0
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             nProfiles += maxIndex - minIndex + 1
                         for thisRange in rangeList:
                             minIndex = thisRange[0]
                             maxIndex = thisRange[1]
                             if self.isThisProfileInRange(dataOut.profileIndex, minIndex, maxIndex):
                                 self.nProfiles = nProfiles
                                 dataOut.nProfiles = self.nProfiles
                                 dataOut.profileIndex = self.profileIndex
                                 dataOut.flagNoData = False
                                 self.incProfileIndex()
                                 break
                         return dataOut
                     if beam != None: #beam is only for AMISR data
                         if self.isThisProfileInList(dataOut.profileIndex, dataOut.beamRangeDict[beam]):
                             dataOut.flagNoData = False
                             dataOut.profileIndex = self.profileIndex
                             self.incProfileIndex()
                         return dataOut
                     raise ValueError("ProfileSelector needs profileList, profileRangeList or rangeList parameter")
             class Reshaper(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__buffer = None
                     self.__nitems = 0
                 def __appendProfile(self, dataOut, nTxs):
                     if self.__buffer is None:
                         shape = (dataOut.nChannels, int(dataOut.nHeights/nTxs) )
                         self.__buffer = numpy.empty(shape, dtype = dataOut.data.dtype)
                     ini = dataOut.nHeights * self.__nitems
                     end = ini + dataOut.nHeights
                     self.__buffer[:, ini:end] = dataOut.data
                     self.__nitems += 1
                     return int(self.__nitems*nTxs)
                 def __getBuffer(self):
                     if self.__nitems == int(1./self.__nTxs):
                         self.__nitems = 0
                         return self.__buffer.copy()
                     return None
                 def __checkInputs(self, dataOut, shape, nTxs):
                     if shape is None and nTxs is None:
                         raise ValueError("Reshaper: shape of factor should be defined")
                     if nTxs:
                         if nTxs < 0:
                             raise ValueError("nTxs should be greater than 0")
                         if nTxs < 1 and dataOut.nProfiles % (1./nTxs) != 0:
                             raise ValueError("nProfiles= %d is not divisibled by (1./nTxs) = %f" %(dataOut.nProfiles, (1./nTxs)))
                         shape = [dataOut.nChannels, dataOut.nProfiles*nTxs, dataOut.nHeights/nTxs]
                         return shape, nTxs
                     if len(shape) != 2 and len(shape) !=  3:
                         raise ValueError("shape dimension should be equal to 2 or 3. shape = (nProfiles, nHeis) or (nChannels, nProfiles, nHeis). Actually shape = (%d, %d, %d)" %(dataOut.nChannels, dataOut.nProfiles, dataOut.nHeights))
                     if len(shape) == 2:
                         shape_tuple = [dataOut.nChannels]
                         shape_tuple.extend(shape)
                     else:
                         shape_tuple = list(shape)
                     nTxs = 1.0*shape_tuple[1]/dataOut.nProfiles
                     return shape_tuple, nTxs
                 def run(self, dataOut, shape=None, nTxs=None):
                     shape_tuple, self.__nTxs = self.__checkInputs(dataOut, shape, nTxs)
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         dataOut.data = numpy.reshape(dataOut.data, shape_tuple)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*self.__nTxs) - 1
                     else:
                         if self.__nTxs < 1:
                             self.__appendProfile(dataOut, self.__nTxs)
                             new_data = self.__getBuffer()
                             if new_data is not None:
                                 dataOut.data = new_data
                                 dataOut.flagNoData = False
                                 profileIndex = dataOut.profileIndex*nTxs
                         else:
                             raise ValueError("nTxs should be greater than 0 and lower than 1, or use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/self.__nTxs) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*self.__nTxs)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= self.__nTxs
                     return dataOut
             class SplitProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         if shape[2] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[2]))
                         new_shape = shape[0], shape[1]*n, int(shape[2]/n)
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles/n) - 1
                     else:
                         raise ValueError("Could not split the data when is read Profile by Profile. Use VoltageReader(..., getblock=True)")
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights/n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles*n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds /= n
                     return dataOut
             class CombineProfiles(Operation):
                 def __init__(self, **kwargs):
                     Operation.__init__(self, **kwargs)
                     self.__remData = None
                     self.__profileIndex = 0
                 def run(self, dataOut, n):
                     dataOut.flagNoData = True
                     profileIndex = None
                     if dataOut.flagDataAsBlock:
                         #nchannels, nprofiles, nsamples
                         shape = dataOut.data.shape
                         new_shape = shape[0], shape[1]/n, shape[2]*n
                         if shape[1] % n != 0:
                             raise ValueError("Could not split the data, n=%d has to be multiple of %d" %(n, shape[1]))
                         dataOut.data = numpy.reshape(dataOut.data, new_shape)
                         dataOut.flagNoData = False
                         profileIndex = int(dataOut.nProfiles*n) - 1
                     else:
                         #nchannels, nsamples
                         if self.__remData is None:
                             newData = dataOut.data
                         else:
                             newData = numpy.concatenate((self.__remData, dataOut.data), axis=1)
                         self.__profileIndex += 1
                         if self.__profileIndex < n:
                             self.__remData = newData
                             #continue
                             return
                         self.__profileIndex = 0
                         self.__remData = None
                         dataOut.data = newData
                         dataOut.flagNoData = False
                         profileIndex = dataOut.profileIndex/n
                     deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
                     dataOut.heightList = numpy.arange(dataOut.nHeights*n) * deltaHeight + dataOut.heightList[0]
                     dataOut.nProfiles = int(dataOut.nProfiles/n)
                     dataOut.profileIndex = profileIndex
                     dataOut.ippSeconds *= n
                     return dataOut
-            class PulsePairVoltage(Operation):
+            class PulsePair(Operation):
                 '''
                 Function PulsePair(Signal Power, Velocity)
                 The real component of Lag[0] provides Intensity Information
                 The imag component of Lag[1] Phase provides Velocity Information
                 Configuration Parameters:
                 nPRF = Number of Several PRF
                 theta = Degree Azimuth angel Boundaries
                 Input:
                       self.dataOut
                       lag[N]
                 Affected:
                       self.dataOut.spc
                 '''
                 isConfig       = False
                 __profIndex    = 0
                 __initime      = None
                 __lastdatatime = None
                 __buffer       = None
                 noise          = None
                 __dataReady    = False
                 n              = None
                 __nch          = 0
                 __nHeis        = 0
                 removeDC       = False
                 ipp            = None
                 lambda_        = 0
                 def __init__(self,**kwargs):
                     Operation.__init__(self,**kwargs)
                 def setup(self, dataOut, n = None, removeDC=False):
                     '''
                     n= Numero de PRF's de entrada
                     '''
+                    print("[INICIO]-setup  del METODO PULSE PAIR")
                     self.__initime        = None
                     self.__lastdatatime   = 0
                     self.__dataReady      = False
                     self.__buffer         = 0
                     self.__profIndex      = 0
                     self.noise            = None
                     self.__nch            = dataOut.nChannels
                     self.__nHeis          = dataOut.nHeights
                     self.removeDC         = removeDC
                     self.lambda_          = 3.0e8/(9345.0e6)
                     self.ippSec           = dataOut.ippSeconds
                     self.nCohInt          = dataOut.nCohInt
                     print("IPPseconds",dataOut.ippSeconds)
                     print("ELVALOR DE n es:", n)
                     if n == None:
                         raise ValueError("n should be specified.")
                     if n != None:
                         if n<2:
                             raise ValueError("n should be greater than 2")
                     self.n       = n
                     self.__nProf = n
                     self.__buffer = numpy.zeros((dataOut.nChannels,
                                                        n,
                                                        dataOut.nHeights),
                                                       dtype='complex')
                 def putData(self,data):
                     '''
                     Add a profile to he __buffer and increase in one the __profiel Index
                     '''
                     self.__buffer[:,self.__profIndex,:]= data
                     self.__profIndex      += 1
                     return
                 def pushData(self,dataOut):
                     '''
                     Return the PULSEPAIR and the profiles used in the operation
                     Affected :  self.__profileIndex
                     '''
                     #----------------- Remove DC-----------------------------------
                     if self.removeDC==True:
                         mean    = numpy.mean(self.__buffer,1)
                         tmp     = mean.reshape(self.__nch,1,self.__nHeis)
                         dc= numpy.tile(tmp,[1,self.__nProf,1])
                         self.__buffer = self.__buffer -  dc
                     #------------------Calculo de Potencia ------------------------
                     pair0       = self.__buffer*numpy.conj(self.__buffer)
                     pair0       = pair0.real
                     lag_0       = numpy.sum(pair0,1)
                     #------------------Calculo de Ruido x canal--------------------
                     self.noise  = numpy.zeros(self.__nch)
                     for i in range(self.__nch):
                         daux         = numpy.sort(pair0[i,:,:],axis= None)
                         self.noise[i]=hildebrand_sekhon( daux ,self.nCohInt)
                     self.noise       = self.noise.reshape(self.__nch,1)
                     self.noise       = numpy.tile(self.noise,[1,self.__nHeis])
                     noise_buffer     = self.noise.reshape(self.__nch,1,self.__nHeis)
                     noise_buffer     = numpy.tile(noise_buffer,[1,self.__nProf,1])
                     #------------------ Potencia recibida= P , Potencia senal = S , Ruido= N--
                     #------------------   P= S+N  ,P=lag_0/N ---------------------------------
                     #-------------------- Power --------------------------------------------------
                     data_power       = lag_0/(self.n*self.nCohInt)
                     #------------------  Senal  ---------------------------------------------------
                     data_intensity   = pair0 - noise_buffer
                     data_intensity   = numpy.sum(data_intensity,axis=1)*(self.n*self.nCohInt)#*self.nCohInt)
                     #data_intensity   = (lag_0-self.noise*self.n)*(self.n*self.nCohInt)
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_intensity[i][j]  < 0:
                                 data_intensity[i][j] = numpy.min(numpy.absolute(data_intensity[i][j]))
                     #----------------- Calculo de Frecuencia y Velocidad doppler--------
                     pair1            = self.__buffer[:,:-1,:]*numpy.conjugate(self.__buffer[:,1:,:])
                     lag_1            = numpy.sum(pair1,1)
                     data_freq        = (-1/(2.0*math.pi*self.ippSec*self.nCohInt))*numpy.angle(lag_1)
                     data_velocity    = (self.lambda_/2.0)*data_freq
                     #---------------- Potencia promedio estimada de la Senal-----------
                     lag_0            = lag_0/self.n
                     S                = lag_0-self.noise
                     #---------------- Frecuencia Doppler promedio ---------------------
                     lag_1            = lag_1/(self.n-1)
                     R1               = numpy.abs(lag_1)
                     #---------------- Calculo del SNR----------------------------------
                     data_snrPP       = S/self.noise
                     for i in range(self.__nch):
                         for j in range(self.__nHeis):
                             if data_snrPP[i][j]  < 1.e-20:
                                 data_snrPP[i][j] = 1.e-20
                     #----------------- Calculo del ancho espectral ----------------------
                     L                = S/R1
                     L                = numpy.where(L<0,1,L)
                     L                = numpy.log(L)
                     tmp              = numpy.sqrt(numpy.absolute(L))
                     data_specwidth   = (self.lambda_/(2*math.sqrt(2)*math.pi*self.ippSec*self.nCohInt))*tmp*numpy.sign(L)
                     n                = self.__profIndex
                     self.__buffer    = numpy.zeros((self.__nch, self.__nProf,self.__nHeis),  dtype='complex')
                     self.__profIndex = 0
                     return data_power,data_intensity,data_velocity,data_snrPP,data_specwidth,n
                 def pulsePairbyProfiles(self,dataOut):
                     self.__dataReady     =  False
                     data_power           =  None
                     data_intensity       =  None
                     data_velocity        =  None
                     data_specwidth       =  None
                     data_snrPP           =  None
                     self.putData(data=dataOut.data)
                     if self.__profIndex  == self.n:
                         data_power,data_intensity, data_velocity,data_snrPP,data_specwidth, n   = self.pushData(dataOut=dataOut)
                         self.__dataReady                   = True
                     return data_power, data_intensity, data_velocity, data_snrPP, data_specwidth
                 def pulsePairOp(self, dataOut, datatime= None):
                     if self.__initime == None:
                         self.__initime = datatime
                     data_power, data_intensity, data_velocity, data_snrPP, data_specwidth = self.pulsePairbyProfiles(dataOut)
                     self.__lastdatatime           = datatime
                     if data_power is None:
                         return None, None, None,None,None,None
                     avgdatatime    = self.__initime
                     deltatime      = datatime - self.__lastdatatime
                     self.__initime = datatime
                     return data_power, data_intensity, data_velocity, data_snrPP, data_specwidth, avgdatatime
                 def run(self, dataOut,n = None,removeDC= False, overlapping= False,**kwargs):
                     if not self.isConfig:
                         self.setup(dataOut = dataOut, n    = n , removeDC=removeDC , **kwargs)
                         self.isConfig   = True
                     data_power, data_intensity, data_velocity,data_snrPP,data_specwidth, avgdatatime = self.pulsePairOp(dataOut, dataOut.utctime)
                     dataOut.flagNoData                         = True
                     if self.__dataReady:
                         dataOut.nCohInt        *= self.n
                         dataOut.dataPP_POW      = data_intensity # S
                         dataOut.dataPP_POWER    = data_power     # P
                         dataOut.dataPP_DOP      = data_velocity
                         dataOut.dataPP_SNR      = data_snrPP
                         dataOut.dataPP_WIDTH    = data_specwidth
                         dataOut.PRFbyAngle      = self.n         #numero de PRF*cada angulo rotado que equivale a un tiempo.
+                        dataOut.nProfiles       = int(dataOut.nProfiles/n)
                         dataOut.utctime         = avgdatatime
                         dataOut.flagNoData      = False
                     return dataOut
             # import collections
             # from scipy.stats import mode
             #
             # class Synchronize(Operation):
             #
             #     isConfig = False
             #     __profIndex = 0
             #
             #     def __init__(self, **kwargs):
             #
             #         Operation.__init__(self, **kwargs)
             # #         self.isConfig = False
             #         self.__powBuffer = None
             #         self.__startIndex = 0
             #         self.__pulseFound = False
             #
             #     def __findTxPulse(self, dataOut, channel=0, pulse_with = None):
             #
             #         #Read data
             #
             #         powerdB = dataOut.getPower(channel = channel)
             #         noisedB = dataOut.getNoise(channel = channel)[0]
             #
             #         self.__powBuffer.extend(powerdB.flatten())
             #
             #         dataArray = numpy.array(self.__powBuffer)
             #
             #         filteredPower = numpy.correlate(dataArray, dataArray[0:self.__nSamples], "same")
             #
             #         maxValue = numpy.nanmax(filteredPower)
             #
             #         if maxValue < noisedB + 10:
             #             #No se encuentra ningun pulso de transmision
             #             return None
             #
             #         maxValuesIndex = numpy.where(filteredPower > maxValue - 0.1*abs(maxValue))[0]
             #
             #         if len(maxValuesIndex) < 2:
             #             #Solo se encontro un solo pulso de transmision de un baudio, esperando por el siguiente TX
             #             return None
             #
             #         phasedMaxValuesIndex = maxValuesIndex - self.__nSamples
             #
             #         #Seleccionar solo valores con un espaciamiento de nSamples
             #         pulseIndex = numpy.intersect1d(maxValuesIndex, phasedMaxValuesIndex)
             #
             #         if len(pulseIndex) < 2:
             #             #Solo se encontro un pulso de transmision con ancho mayor a 1
             #             return None
             #
             #         spacing = pulseIndex[1:] - pulseIndex[:-1]
             #
             #         #remover senales que se distancien menos de 10 unidades o muestras
             #         #(No deberian existir IPP menor a 10 unidades)
             #
             #         realIndex = numpy.where(spacing > 10 )[0]
             #
             #         if len(realIndex) < 2:
             #             #Solo se encontro un pulso de transmision con ancho mayor a 1
             #             return None
             #
             #         #Eliminar pulsos anchos (deja solo la diferencia entre IPPs)
             #         realPulseIndex = pulseIndex[realIndex]
             #
             #         period = mode(realPulseIndex[1:] - realPulseIndex[:-1])[0][0]
             #
             #         print "IPP = %d samples" %period
             #
             #         self.__newNSamples = dataOut.nHeights #int(period)
             #         self.__startIndex = int(realPulseIndex[0])
             #
             #         return 1
             #
             #
             #     def setup(self, nSamples, nChannels, buffer_size = 4):
             #
             #         self.__powBuffer = collections.deque(numpy.zeros( buffer_size*nSamples,dtype=numpy.float),
             #                                           maxlen = buffer_size*nSamples)
             #
             #         bufferList = []
             #
             #         for i in range(nChannels):
             #             bufferByChannel = collections.deque(numpy.zeros( buffer_size*nSamples, dtype=numpy.complex) +  numpy.NAN,
             #                                           maxlen = buffer_size*nSamples)
             #
             #             bufferList.append(bufferByChannel)
             #
             #         self.__nSamples = nSamples
             #         self.__nChannels = nChannels
             #         self.__bufferList = bufferList
             #
             #     def run(self, dataOut, channel = 0):
             #
             #         if not self.isConfig:
             #             nSamples = dataOut.nHeights
             #             nChannels = dataOut.nChannels
             #             self.setup(nSamples, nChannels)
             #             self.isConfig = True
             #
             #         #Append new data to internal buffer
             #         for thisChannel in range(self.__nChannels):
             #             bufferByChannel = self.__bufferList[thisChannel]
             #             bufferByChannel.extend(dataOut.data[thisChannel])
             #
             #         if self.__pulseFound:
             #             self.__startIndex -= self.__nSamples
             #
             #         #Finding Tx Pulse
             #         if not self.__pulseFound:
             #             indexFound = self.__findTxPulse(dataOut, channel)
             #
             #             if indexFound == None:
             #                 dataOut.flagNoData = True
             #                 return
             #
             #             self.__arrayBuffer = numpy.zeros((self.__nChannels, self.__newNSamples), dtype = numpy.complex)
             #             self.__pulseFound = True
             #             self.__startIndex = indexFound
             #
             #         #If pulse was found ...
             #         for thisChannel in range(self.__nChannels):
             #             bufferByChannel = self.__bufferList[thisChannel]
             #             #print self.__startIndex
             #             x = numpy.array(bufferByChannel)
             #             self.__arrayBuffer[thisChannel] = x[self.__startIndex:self.__startIndex+self.__newNSamples]
             #
             #         deltaHeight = dataOut.heightList[1] - dataOut.heightList[0]
             #         dataOut.heightList = numpy.arange(self.__newNSamples)*deltaHeight
             # #             dataOut.ippSeconds = (self.__newNSamples / deltaHeight)/1e6
             #
             #         dataOut.data = self.__arrayBuffer
             #
             #         self.__startIndex += self.__newNSamples
             #
             #         return

schainpy/scripts/USRP_PLOT_THOR.py +100 -35

             #!python
             '''
             '''
             import os, sys
             import datetime
             import time
             #path = os.path.dirname(os.getcwd())
             #path = os.path.dirname(path)
             #sys.path.insert(0, path)
             from schainpy.controller import Project
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
             #######################################################################
             ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
             #######################################################################
             #path = '/media/data/data/vientos/57.2063km/echoes/NCO_Woodman'
+            #path = '/DATA_RM/TEST_INTEGRACION'
+            path = '/DATA_RM/TEST_ONLINE'
-            path = '/home/soporte/data_hdf5' #### with clock   35.16 db noise
+            figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
-            figpath = '/home/soporte/data_hdf5_imag'
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             #######################################################################
-            dBmin = '30'
+            dBmin = '-5'
-            dBmax = '60'
+            dBmax = '20'
             xmin = '0'
             xmax ='24'
             ymin = '0'
             ymax = '600'
             #######################################################################
             ########################FECHA##########################################
             #######################################################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
-                                                        startDate="2019/01/01",#today,
+                                                        startDate="2021/01/01",#today,
-                                                        endDate="2109/12/30",#today,
+                                                        endDate="2021/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
-                                                        ippKm = 1000)
+                                                        ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
-            opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
+            #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
             #######################################################################
             ################ OPERACIONES DOMINIO DEL TIEMPO########################
             #######################################################################
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             #
             # codigo64='1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,1,1,1,0,0,0,1,0,'+\
             #              '1,1,1,0,1,1,0,1,1,1,1,0,0,0,1,0,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,1,1,1,0,1,1,0,1,0,0,0,1,1,1,0,1'
             #opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
-            #opObj11.addParameter(name='frequency', value='30e6', format='float')
+            #opObj11.addParameter(name='frequency', value='70312500')
+            '''
+            opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
+            opObj11.addParameter(name='n', value='625', format='int')#10
+            opObj11.addParameter(name='removeDC', value=1, format='int')
+            '''
-            #opObj10 = procUnitConfObjA.addOperation(name='Scope', optype='external')
+            # Ploteo TEST
+            '''
+            opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
+            opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
+            opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
+            #opObj11.addParameter(name='xmax', value=8)
+            opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
+            '''
+            # OJO SCOPE
+            #opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
             #opObj10.addParameter(name='id', value='10', format='int')
             ##opObj10.addParameter(name='xmin', value='0', format='int')
             ##opObj10.addParameter(name='xmax', value='50', format='int')
             #opObj10.addParameter(name='type', value='iq')
-            #opObj10.addParameter(name='ymin', value='-5000', format='int')
+            ##opObj10.addParameter(name='ymin', value='-5000', format='int')
             ##opObj10.addParameter(name='ymax', value='8500', format='int')
+            #opObj11.addParameter(name='save', value=figpath, format='str')
+            #opObj11.addParameter(name='save_period', value=10, format='int')
             #opObj10 = procUnitConfObjA.addOperation(name='setH0')
             #opObj10.addParameter(name='h0', value='-5000', format='float')
             #opObj11 =  procUnitConfObjA.addOperation(name='filterByHeights')
             #opObj11.addParameter(name='window', value='1', format='int')
             #codigo='1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,-1,-1,-1,1,1,1,1,-1,-1,-1'
             #opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
             #opObj11.addParameter(name='code', value=codigo, format='floatlist')
             #opObj11.addParameter(name='nCode', value='1', format='int')
             #opObj11.addParameter(name='nBaud', value='28', format='int')
             #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
             #opObj11.addParameter(name='n', value='100', format='int')
             #######################################################################
+            ########## OPERACIONES ParametersProc########################
+            #######################################################################
+            ###procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
+            '''
+            opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
+            opObj11.addParameter(name='path_ped', value=path_ped)
+            opObj11.addParameter(name='path_adq', value=path_adq)
+            opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
+            opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
+            opObj11.addParameter(name='blocksPerfile', value='100', format='int')
+            opObj11.addParameter(name='f_a_p', value='25', format='int')
+            opObj11.addParameter(name='online', value='0', format='int')
+            opObj11 = procUnitConfObjA.addOperation(name='Block360')
+            opObj11.addParameter(name='n', value='40', format='int')
+            opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
+            opObj11.addParameter(name='save', value=figpath)
+            opObj11.addParameter(name='save_period', value=1)
+            '''
+            #######################################################################
             ########## OPERACIONES DOMINIO DE LA FRECUENCIA########################
             #######################################################################
-            procUnitConfObjSousySpectra = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
-            procUnitConfObjSousySpectra.addParameter(name='nFFTPoints', value='100', format='int')
-            procUnitConfObjSousySpectra.addParameter(name='nProfiles', value='100', format='int')
-            #procUnitConfObjSousySpectra.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList')
-            #opObj13 = procUnitConfObjSousySpectra.addOperation(name='removeDC')
+            procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
+            procUnitConfObjB.addParameter(name='nFFTPoints', value='32', format='int')
+            procUnitConfObjB.addParameter(name='nProfiles', value='32', format='int')
+            procUnitConfObjC = controllerObj.addProcUnit(datatype='SpectraHeisProc', inputId=procUnitConfObjA.getId())
+            #procUnitConfObjB.addParameter(name='nFFTPoints', value='64', format='int')
+            #procUnitConfObjB.addParameter(name='nProfiles', value='64', format='int')
+            opObj11 = procUnitConfObjC.addOperation(name='IncohInt4SpectraHeis', optype='other')
+            opObj11.addParameter(name='timeInterval', value='8', format='int')
+            #procUnitConfObjB.addParameter(name='pairsList', value='(0,0),(1,1),(0,1)', format='pairsList')
+            #opObj13 = procUnitConfObjB.addOperation(name='removeDC')
             #opObj13.addParameter(name='mode', value='2', format='int')
-            #opObj11 = procUnitConfObjSousySpectra.addOperation(name='IncohInt', optype='other')
+            opObj11 = procUnitConfObjB.addOperation(name='IncohInt', optype='other')
-            #opObj11.addParameter(name='n', value='60', format='float')
+            opObj11.addParameter(name='n', value='8', format='float')
             #######################################################################
             ########## PLOTEO DOMINIO DE LA FRECUENCIA#############################
             #######################################################################
+            #----
+            opObj11 = procUnitConfObjC.addOperation(name='SpectraHeisPlot')
+            opObj11.addParameter(name='id', value='10', format='int')
+            opObj11.addParameter(name='wintitle', value='Spectra_Alturas', format='str')
+            #opObj11.addParameter(name='xmin', value=-100000, format='float')
+            #opObj11.addParameter(name='xmax', value=100000, format='float')
+            #opObj11.addParameter(name='zmin', value=dBmin, format='int')
+            #opObj11.addParameter(name='zmax', value=dBmax, format='int')
+            opObj11.addParameter(name='ymin', value=-20, format='int')
+            opObj11.addParameter(name='ymax', value=50, format='int')
+            opObj11.addParameter(name='showprofile', value='1', format='int')
+            opObj11.addParameter(name='save', value=figpath, format='str')
+            opObj11.addParameter(name='save_period', value=10, format='int')
             #SpectraPlot
-            opObj11 = procUnitConfObjSousySpectra.addOperation(name='SpectraPlot', optype='external')
+            opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
             opObj11.addParameter(name='id', value='1', format='int')
             opObj11.addParameter(name='wintitle', value='Spectra', format='str')
             #opObj11.addParameter(name='xmin', value=-0.01, format='float')
             #opObj11.addParameter(name='xmax', value=0.01, format='float')
-            #opObj11.addParameter(name='zmin', value=dBmin, format='int')
+            opObj11.addParameter(name='zmin', value=dBmin, format='int')
-            #opObj11.addParameter(name='zmax', value=dBmax, format='int')
+            opObj11.addParameter(name='zmax', value=dBmax, format='int')
             #opObj11.addParameter(name='ymin', value=ymin, format='int')
             #opObj11.addParameter(name='ymax', value=ymax, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
             #RTIPLOT
-            opObj11 = procUnitConfObjSousySpectra.addOperation(name='RTIPlot', optype='external')
+            opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external')
             opObj11.addParameter(name='id', value='2', format='int')
             opObj11.addParameter(name='wintitle', value='RTIPlot', format='str')
-            #opObj11.addParameter(name='zmin', value=dBmin, format='int')
+            opObj11.addParameter(name='zmin', value=dBmin, format='int')
-            #opObj11.addParameter(name='zmax', value=dBmax, format='int')
+            opObj11.addParameter(name='zmax', value=dBmax, format='int')
             #opObj11.addParameter(name='ymin', value=ymin, format='int')
             #opObj11.addParameter(name='ymax', value=ymax, format='int')
-            opObj11.addParameter(name='xmin', value=0, format='int')
+            #opObj11.addParameter(name='xmin', value=15, format='int')
-            opObj11.addParameter(name='xmax', value=23, format='int')
+            #opObj11.addParameter(name='xmax', value=16, format='int')
             opObj11.addParameter(name='showprofile', value='1', format='int')
             opObj11.addParameter(name='save', value=figpath, format='str')
             opObj11.addParameter(name='save_period', value=10, format='int')
-            # opObj11 = procUnitConfObjSousySpectra.addOperation(name='CrossSpectraPlot', optype='other')
+            # opObj11 = procUnitConfObjB.addOperation(name='CrossSpectraPlot', optype='other')
             # opObj11.addParameter(name='id', value='3', format='int')
             # opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
             # opObj11.addParameter(name='ymin', value=ymin, format='int')
             # opObj11.addParameter(name='ymax', value=ymax, format='int')
             # opObj11.addParameter(name='phase_cmap', value='jet', format='str')
             # opObj11.addParameter(name='zmin', value=dBmin, format='int')
             # opObj11.addParameter(name='zmax', value=dBmax, format='int')
             # opObj11.addParameter(name='figpath', value=figures_path, format='str')
             # opObj11.addParameter(name='save', value=0, format='bool')
             # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
             # #
-            # opObj11 = procUnitConfObjSousySpectra.addOperation(name='CoherenceMap', optype='other')
+            # opObj11 = procUnitConfObjB.addOperation(name='CoherenceMap', optype='other')
             # opObj11.addParameter(name='id', value='4', format='int')
             # opObj11.addParameter(name='wintitle', value='Coherence', format='str')
             # opObj11.addParameter(name='phase_cmap', value='jet', format='str')
             # opObj11.addParameter(name='xmin', value=xmin, format='float')
             # opObj11.addParameter(name='xmax', value=xmax, format='float')
             # opObj11.addParameter(name='figpath', value=figures_path, format='str')
             # opObj11.addParameter(name='save', value=0, format='bool')
             # opObj11.addParameter(name='pairsList', value='(0,1)', format='pairsList')
             #
+            '''
             #######################################################################
             ############### UNIDAD DE ESCRITURA ###################################
             #######################################################################
-            #opObj11 = procUnitConfObjSousySpectra.addOperation(name='SpectraWriter', optype='other')
+            #opObj11 = procUnitConfObjB.addOperation(name='SpectraWriter', optype='other')
             #opObj11.addParameter(name='path', value=wr_path)
             #opObj11.addParameter(name='blocksPerFile', value='50', format='int')
             print ("Escribiendo el archivo XML")
             print ("Leyendo el archivo XML")
+            '''
             controllerObj.start()

schainpy/scripts/test_sim00010.py +21 -10

             import os, sys
             import datetime
             import time
             from schainpy.controller import Project
+            '''
+            NOTA:
+            Este script de prueba.
+            - Unidad del lectura 'SimulatorReader'.
+            - Unidad de procesamiento VoltageProc
+            - Unidad de procesamiento SpectraProc (profileIndex no esta en metadata porque se queda en voltage.)
+            - Operacion removeDC.
+            - Unidad de procesamiento ParametersProc
+            - Operacion SpectralMoments
+            - Operacion SpectralMomentsPlot
+            - Unidad de escrituda 'HDFWriter'.
+            '''
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             ############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
             ######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
-            path    = '/home/alex/Downloads/test_rawdata'
+            path    = '/home/soporte/Downloads/RAWDATA'
-            figpath = '/home/alex/Downloads/hdf5_test'
+            figpath = '/home/soporte/Downloads/IMAGE'
             ######################## UNIDAD DE LECTURA#############################
             '''
             readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
                                                         path=path,
                                                         startDate="2020/01/01",   #"2020/01/01",#today,
                                                         endDate= "2020/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1)
             '''
             readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
                                                         frequency=9.345e9,
                                                         FixRCP_IPP= 60,
                                                         Tau_0 = 30,
                                                         AcqH0_0=0,
                                                         samples=330,
                                                         AcqDH_0=0.15,
                                                         FixRCP_TXA=0.15,
                                                         FixRCP_TXB=0.15,
                                                         Fdoppler=600.0,
                                                         Hdoppler=36,
                                                         Adoppler=300,#300
                                                         delay=0,
                                                         online=0,
                                                         walk=0,
                                                         profilesPerBlock=625,
                                                         dataBlocksPerFile=100)
                                                         #nTotalReadFiles=2)
             #opObj11 = readUnitConfObj.addOperation(name='printInfo')
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
             procUnitConfObjB.addParameter(name='nFFTPoints', value=625, format='int')
             procUnitConfObjB.addParameter(name='nProfiles', value=625, format='int')
             opObj11 = procUnitConfObjB.addOperation(name='removeDC')
             opObj11.addParameter(name='mode', value=2)
             #opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot')
             #opObj11 = procUnitConfObjB.addOperation(name='PowerProfilePlot')
             procUnitConfObjC= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
             procUnitConfObjC.addOperation(name='SpectralMoments')
             #opObj11 = procUnitConfObjC.addOperation(name='PowerPlot')
-            '''
             opObj11 = procUnitConfObjC.addOperation(name='SpectralMomentsPlot')
             #opObj11.addParameter(name='xmin', value=14)
             #opObj11.addParameter(name='xmax', value=15)
-            #opObj11.addParameter(name='save', value=figpath)
+            opObj11.addParameter(name='save', value=figpath)
             opObj11.addParameter(name='showprofile', value=1)
-            #opObj11.addParameter(name='save_period', value=10)
+            opObj11.addParameter(name='save_period', value=10)
-            '''
-            opObj10 = procUnitConfObjC.addOperation(name='ParameterWriter')
+            opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
-            opObj10.addParameter(name='path',value=figpath)
+            opObj10.addParameter(name='path',value=path)
             #opObj10.addParameter(name='mode',value=0)
             opObj10.addParameter(name='blocksPerFile',value='100',format='int')
-            opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
+            opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
-            opObj10.addParameter(name='dataList',value='data_POW,data_DOP,data_WIDTH,data_SNR')#,format='list'
+            opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
             controllerObj.start()

schainpy/scripts/test_sim0009.py +4 -4

             import os,sys
             import datetime
             import time
             from schainpy.controller import Project
-            path    = '/home/alex/Downloads/NEW_WR2/spc16removeDC'
+            path    = '/home/soporte/Downloads/RAWDATA_PP'
             figpath = path
             desc            = "Simulator Test"
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='SimulatorReader',
                                                         frequency=9.345e9,
                                                         FixRCP_IPP= 60,
                                                         Tau_0 = 30,
                                                         AcqH0_0=0,
                                                         samples=330,
                                                         AcqDH_0=0.15,
                                                         FixRCP_TXA=0.15,
                                                         FixRCP_TXB=0.15,
                                                         Fdoppler=600.0,
                                                         Hdoppler=36,
                                                         Adoppler=300,#300
                                                         delay=0,
                                                         online=0,
                                                         walk=0,
                                                         profilesPerBlock=625,
                                                         dataBlocksPerFile=100)#,#nTotalReadFiles=2)
             '''
             readUnitConfObj = controllerObj.addReadUnit(datatype='VoltageReader',
                                                         path=path,
                                                         startDate="2020/01/01",   #"2020/01/01",#today,
                                                         endDate= "2020/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1)
             '''
             opObj11         = readUnitConfObj.addOperation(name='printInfo')
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
             #opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
             #opObj11.addParameter(name='n', value='10', format='int')
             #opObj10 = procUnitConfObjA.addOperation(name='selectChannels')
             #opObj10.addParameter(name='channelList', value=[0])
             opObj11 = procUnitConfObjA.addOperation(name='PulsePairVoltage', optype='other')
             opObj11.addParameter(name='n', value='625', format='int')#10
             opObj11.addParameter(name='removeDC', value=1, format='int')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
             #opObj11.addParameter(name='xmax', value=8)
             #opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
             procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
-            opObj10 = procUnitConfObjB.addOperation(name='ParameterWriter')
+            opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
             opObj10.addParameter(name='path',value=figpath)
             #opObj10.addParameter(name='mode',value=0)
             opObj10.addParameter(name='blocksPerFile',value='100',format='int')
-            opObj10.addParameter(name='metadataList',value='utctimeInit,timeInterval',format='list')
+            opObj10.addParameter(name='metadataList',value='utctimeInit,paramInterval,profileIndex,heightList,flagDataAsBlock',format='list')
-            opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,dataPP_SNR,dataPP_WIDTH')#,format='list'
+            opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,dataPP_SNR,dataPP_WIDTH,utctime',format='list')#,format='list'
             controllerObj.start()

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages