schain Commit - r1405:49f004b59e80 · Jicamarca Repository

last 30-16:19

avaldezp -

r1405:49f004b59e80

parent child

Context file:

r1405:49f004b59e80

Collapse all files

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

schainpy/SOPHY_test0001.py created 644 +41 0

@@ -0,0 +1,41
	1	# Ing. AVP
	2	# 01/11/2021
	3	# ARCHIVO DE LECTURA
	4	import os, sys
	5	import datetime
	6	import time
	7	from schainpy.controller import Project
	8	print("----[Setup]-RadarMeteorologico--------")
	9	Vel = 6
	10	modo_proc = 1
	11	#-----------PATH DE DATOS-----------------------#
	12	path = "/DATA_RM/10"
	13	path_ped = "/DATA_RM/TEST_PEDESTAL/P20211111-173856"
	14	print("----[OPCIONES]------------------------")
	15	op_plot = 0
	16	op_integration = 0
	17	op_save = 0
	18	op_plot_spec = 0
	19
	20	########################SIGNAL CHAIN ##################################
	21	desc = "USRP_test"
	22	filename = "USRP_processing.xml"
	23	controllerObj = Project()
	24	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	25	######################## UNIDAD DE LECTURA#############################
	26	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	27	path=path,
	28	startDate="2021/11/11",#today,
	29	endDate="2021/12/30",#today,
	30	startTime='17:39:25',
	31	endTime='23:59:59',
	32	delay=0,
	33	#set=0,
	34	online=0,
	35	walk=1,
	36	ippKm = 60)
	37
	38	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	39
	40	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc',inputId=readUnitConfObj.getId())
	41	controllerObj.start()

schainpy/scripts/IQ_digitalRF.py created 644 +72 0

@@ -0,0 +1,72
	1	import os, sys
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5
	6	desc = "USRP_test"
	7	filename = "USRP_processing.xml"
	8	controllerObj = Project()
	9	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	10
	11	############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
	12	######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
	13	path = '/home/alex/Downloads/test_rawdata'
	14	path = '/DATA_RM/WR_POT_09_2'
	15	figpath = '/home/alex/Downloads'
	16	figpath_pp = "/home/soporte/Pictures/TEST_POT"
	17	################# RANGO DE PLOTEO######################################
	18	dBmin = '30'
	19	dBmax = '60'
	20	xmin = '0'
	21	xmax ='24'
	22	ymin = '0'
	23	ymax = '600'
	24	########################FECHA##########################################
	25	str = datetime.date.today()
	26	today = str.strftime("%Y/%m/%d")
	27	str2 = str - datetime.timedelta(days=1)
	28	yesterday = str2.strftime("%Y/%m/%d")
	29	######################## UNIDAD DE LECTURA#############################
	30	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	31	path=path,
	32	startDate="2021/01/01", #"2020/01/01",#today,
	33	endDate= "2021/12/01", #"2020/12/30",#today,
	34	startTime='00:00:00',
	35	endTime='23:59:59',
	36	delay=0,
	37	#set=0,
	38	online=0,
	39	walk =1,
	40	ippKm = 60 )
	41
	42	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	43	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	44	#######################################################################
	45	################ OPERACIONES DOMINIO DEL TIEMPO########################
	46	#######################################################################
	47
	48	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	49	'''
	50	opObj11 = procUnitConfObjA.addOperation(name='PulsePairVoltage', optype='other')
	51	opObj11.addParameter(name='n', value='256', format='int')
	52	opObj11.addParameter(name='removeDC', value=1, format='int')
	53	'''
	54
	55	_type="iq"
	56	opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	57	#opObj10.addParameter(name='id', value='12')
	58	opObj10.addParameter(name='wintitle', value=_type )
	59	opObj10.addParameter(name='type', value=_type)
	60
	61
	62	'''
	63	type="WeatherPower"
	64	opObj10 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='external')
	65	#opObj10.addParameter(name='id', value='12')
	66	opObj10.addParameter(name='wintitle', value=type )
	67
	68	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	69	opObj11.addParameter(name='xmax', value=8)
	70	'''
	71
	72	controllerObj.start()

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

@@ -0,0 +1,118
	1	# Ing. AVP
	2	# 01/11/2021
	3	# ARCHIVO DE LECTURA
	4	import os, sys
	5	import datetime
	6	import time
	7	from schainpy.controller import Project
	8	print("----[Setup]-RadarMeteorologico--------")
	9	Vel = 10
	10	modo_proc = 0 # 0 Pulse Pair 1 Spectros
	11	#-----------PATH DE DATOS-----------------------#
	12	#------------VERIFICAR SIEMPRE LA FECHA DE LA DATA
	13	path = "/DATA_RM/10"
	14	path_ped = "/DATA_RM/TEST_PEDESTAL/P20211110-171003"
	15	figpath_pp = "/home/soporte/Pictures/TEST_POT"
	16	figpath_ppi_pp = "/home/soporte/Pictures/ppi_PP_30DIC_4"
	17	#-------------------------------------------------------------------
	18	print("----[OPCIONES]------------------------")
	19	op_plot = 0
	20	op_integration = 1
	21	op_save = 1
	22	op_plot_spec = 0
	23	#-------------------------------------
	24	################# RANGO DE PLOTEO######################################
	25	dBmin = '1'
	26	dBmax = '85'
	27	xmin = '17.1'
	28	xmax = '17.25'
	29	ymin = '0'
	30	ymax = '600'
	31	#-------------------NRO Perfiles PROCESAMIENTO --------------------
	32	V=Vel
	33	IPP=400*1e-6
	34	n= int(1/(V*IPP))
	35	print("* n - NRO Perfiles Proc:", n )
	36	time.sleep(3)
	37
	38	#------------------------SIGNAL CHAIN ------------------------------
	39	desc = "USRP_test"
	40	filename = "USRP_processing.xml"
	41	controllerObj = Project()
	42	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	43	######################## UNIDAD DE LECTURA#############################
	44	readUnitConfObj = controllerObj.addReadUnit(datatype = 'DigitalRFReader',
	45	path = path,
	46	startDate= "2021/11/10",#today,
	47	endDate = "2021/12/30",#today,
	48	startTime= '00:00:25',
	49	endTime = '23:59:59',
	50	delay = 0,
	51	online = 0,
	52	walk = 1,
	53	ippKm = 60)
	54
	55	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	56	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc',inputId=readUnitConfObj.getId())
	57
	58	opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
	59	opObj11.addParameter(name='minIndex', value='1', format='int')
	60	# opObj11.addParameter(name='maxIndex', value='10000', format='int')
	61	opObj11.addParameter(name='maxIndex', value='400', format='int')
	62
	63	if modo_proc ==0:
	64	#----------------------------------------PULSE PAIR --------------------------------------------------#
	65	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	66	opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO QUE LA VELOCIDAD ES 10 GRADOS
	67	#opObj11.addParameter(name='removeDC', value=1, format='int')
	68	#------------------------ METODO Parametros -----------------------------------------------------------
	69	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	70	if op_plot==1:
	71	opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
	72	opObj11.addParameter(name='attr_data', value='dataPP_POW')
	73	opObj11.addParameter(name='colormap', value='jet')
	74	#opObj11.addParameter(name='xmin', value=xmin)
	75	#opObj11.addParameter(name='xmax', value=xmax)
	76	opObj11.addParameter(name='zmin', value=dBmin)
	77	opObj11.addParameter(name='zmax', value=dBmax)
	78	opObj11.addParameter(name='save', value=figpath_pp)
	79	opObj11.addParameter(name='showprofile', value=0)
	80	opObj11.addParameter(name='save_period', value=50)
	81
	82	####################### METODO ESCRITURA #######################################################################
	83
	84	if op_integration==1:
	85	V=V
	86	blocksPerfile=100
	87	print("* Velocidad del Pedestal:",V)
	88	tmp_blocksPerfile = 100
	89	f_a_p= int(tmp_blocksPerfile/V)
	90
	91	opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation')
	92	opObj11.addParameter(name='path_ped', value=path_ped)
	93	#opObj11.addParameter(name='path_adq', value=path_adq)
	94	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	95	opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
	96	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	97	opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
	98	opObj11.addParameter(name='online', value='0', format='int')
	99
	100	opObj11 = procUnitConfObjB.addOperation(name='Block360')
	101	opObj11.addParameter(name='n', value='10', format='int')
	102	opObj11.addParameter(name='mode', value=modo_proc, format='int')
	103
	104	# este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
	105
	106	opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
	107	opObj11.addParameter(name='save', value=figpath_ppi_pp)
	108	opObj11.addParameter(name='save_period', value=1)
	109
	110	if op_save==1:
	111	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	112	opObj10.addParameter(name='path',value=figpath_ppi_pp)
	113	#opObj10.addParameter(name='mode',value=0)
	114	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	115	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	116	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,azimuth,utctime',format='list')#,format='list'
	117
	118	controllerObj.start()

schainpy/scripts/avp_001.py created 644 +14 0

@@ -0,0 +1,14
	1	import numpy
	2	a= numpy.array([0,1,2,3,4,5,10,11,12,18,19,20,21,22,23,24,25,26,27,28])
	3	print(a)
	4	list=[]
	5	list2=[]
	6	for i in reversed(range(1,len(a))):
	7	dif=int(a[i])-int(a[i-1])
	8	print(i,a[i],dif )
	9	if dif>1:
	10	list.append(i-1)
	11	list2.append(dif-1)
	12	print("result")
	13	print(list)
	14	print(list2)

schainpy/scripts/pp__proc.py created 644 +147 0

@@ -0,0 +1,147
	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 = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
	29	# ULTIMO TEST 22 DE SEPTIEMBRE
	30	path = '/DATA_RM/USRP_22'
	31	#path_pp = '/DATA_RM/TEST_HDF5'
	32	# UTIMO TEST 22 DE SEPTIEMBRE
	33	path_pp = '/DATA_RM/TEST_HDF5_PP_22'
	34	######################################################
	35	##### OJO TENER EN CUENTA EL n= para el Pulse Pair ###
	36	######################################################
	37	######## BUSCAMOS EL numero de IPP equivalente 1°#####
	38	######## Sea V la velocidad del Pedestal en °/seg#####
	39	######## 1° sera Recorrido en un tiempo de 1/V ######
	40	######## IPP del Radar 400 useg --> 60 Km ############
	41	######## n = 1/(V*IPP) , NUMERO DE IPP #############
	42	######## n = 1/(V*IPP) #############################
	43	V=2
	44	IPP=400*1e-6
	45	n= 1/(V*IPP)
	46	print("n numero de Perfiles a procesar con Pulse Pair: ", n)
	47
	48
	49
	50
	51	figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
	52	#remotefolder = "/home/wmaster/graficos"
	53	#######################################################################
	54	################# RANGO DE PLOTEO######################################
	55	#######################################################################
	56	dBmin = '-5'
	57	dBmax = '20'
	58	xmin = '0'
	59	xmax ='24'
	60	ymin = '0'
	61	ymax = '600'
	62	#######################################################################
	63	########################FECHA##########################################
	64	#######################################################################
	65	str = datetime.date.today()
	66	today = str.strftime("%Y/%m/%d")
	67	str2 = str - datetime.timedelta(days=1)
	68	yesterday = str2.strftime("%Y/%m/%d")
	69	#######################################################################
	70	######################## UNIDAD DE LECTURA#############################
	71	#######################################################################
	72	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	73	path=path,
	74	startDate="2021/01/01",#today,
	75	endDate="2021/12/30",#today,
	76	startTime='00:00:00',
	77	endTime='23:59:59',
	78	delay=0,
	79	#set=0,
	80	online=0,
	81	walk=1,
	82	ippKm = 60)
	83
	84	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	85	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	86	#######################################################################
	87	################ OPERACIONES DOMINIO DEL TIEMPO########################
	88	#######################################################################
	89
	90	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	91
	92	#
	93	# 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,'+\
	94	# '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'
	95
	96	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	97	#opObj11.addParameter(name='frequency', value='70312500')
	98	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	99	opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO QUE LA VELOCIDAD ES 10 GRADOS
	100	opObj11.addParameter(name='removeDC', value=1, format='int')
	101	# Ploteo TEST
	102	'''
	103	opObj11 = procUnitConfObjA.addOperation(name='PulsepairPowerPlot', optype='other')
	104	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSignalPlot', optype='other')
	105	opObj11 = procUnitConfObjA.addOperation(name='PulsepairVelocityPlot', optype='other')
	106	#opObj11.addParameter(name='xmax', value=8)
	107	opObj11 = procUnitConfObjA.addOperation(name='PulsepairSpecwidthPlot', optype='other')
	108	'''
	109	# OJO SCOPE
	110	#opObj10 = procUnitConfObjA.addOperation(name='ScopePlot', optype='external')
	111	#opObj10.addParameter(name='id', value='10', format='int')
	112	##opObj10.addParameter(name='xmin', value='0', format='int')
	113	##opObj10.addParameter(name='xmax', value='50', format='int')
	114	#opObj10.addParameter(name='type', value='iq')
	115	##opObj10.addParameter(name='ymin', value='-5000', format='int')
	116	##opObj10.addParameter(name='ymax', value='8500', format='int')
	117	#opObj11.addParameter(name='save', value=figpath, format='str')
	118	#opObj11.addParameter(name='save_period', value=10, format='int')
	119
	120	#opObj10 = procUnitConfObjA.addOperation(name='setH0')
	121	#opObj10.addParameter(name='h0', value='-5000', format='float')
	122
	123	#opObj11 = procUnitConfObjA.addOperation(name='filterByHeights')
	124	#opObj11.addParameter(name='window', value='1', format='int')
	125
	126	#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'
	127	#opObj11 = procUnitConfObjSousy.addOperation(name='Decoder', optype='other')
	128	#opObj11.addParameter(name='code', value=codigo, formatyesterday='floatlist')
	129	#opObj11.addParameter(name='nCode', value='1', format='int')
	130	#opObj11.addParameter(name='nBaud', value='28', format='int')
	131
	132	#opObj11 = procUnitConfObjA.addOperation(name='CohInt', optype='other')
	133	#opObj11.addParameter(name='n', value='100', format='int')
	134
	135	#######################################################################
	136	########## OPERACIONES ParametersProc########################
	137	#######################################################################
	138
	139	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	140	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	141	opObj10.addParameter(name='path',value=path_pp)
	142	#opObj10.addParameter(name='mode',value=0)
	143	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	144	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	145	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	146
	147	controllerObj.start()

schainpy/scripts/pp_proc.py created 644 +115 0

@@ -0,0 +1,115
	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 = '/DATA_RM/TEST_INTEGRACION/ADQ_OFFLINE/'
	29	# ULTIMO TEST 22 DE SEPTIEMBRE
	30	path = '/DATA_RM/USRP_22'
	31	#path_pp = '/DATA_RM/TEST_HDF5'
	32	# UTIMO TEST 22 DE SEPTIEMBRE
	33	path_pp = '/DATA_RM/TEST_HDF5_PP_22'
	34	######################################################
	35	##### OJO TENER EN CUENTA EL n= para el Pulse Pair ###
	36	######################################################
	37	######## BUSCAMOS EL numero de IPP equivalente 1°#####
	38	######## Sea V la velocidad del Pedestal en °/seg#####
	39	######## 1° sera Recorrido en un tiempo de 1/V ######
	40	######## IPP del Radar 400 useg --> 60 Km ############
	41	######## n = 1/(V*IPP) , NUMERO DE IPP #############
	42	######## n = 1/(V*IPP) #############################
	43	V=2
	44	IPP=400*1e-6
	45	n= 1/(V*IPP)
	46	print("n numero de Perfiles a procesar con Pulse Pair: ", n)
	47
	48
	49
	50
	51	figpath = '/home/soporte/Pictures/TEST_INTEGRACION_IMG'
	52	#remotefolder = "/home/wmaster/graficos"
	53	#######################################################################
	54	################# RANGO DE PLOTEO######################################
	55	#######################################################################
	56	dBmin = '-5'
	57	dBmax = '20'
	58	xmin = '0'
	59	xmax ='24'
	60	ymin = '0'
	61	ymax = '600'
	62	#######################################################################
	63	########################FECHA##########################################
	64	#######################################################################
	65	str = datetime.date.today()
	66	today = str.strftime("%Y/%m/%d")
	67	str2 = str - datetime.timedelta(days=1)
	68	yesterday = str2.strftime("%Y/%m/%d")
	69	#######################################################################
	70	######################## UNIDAD DE LECTURA#############################
	71	#######################################################################
	72	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	73	path=path,
	74	startDate="2021/01/01",#today,
	75	endDate="2021/12/30",#today,
	76	startTime='00:00:00',
	77	endTime='23:59:59',
	78	delay=0,
	79	#set=0,
	80	online=0,
	81	walk=1,
	82	ippKm = 60)
	83
	84	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	85	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	86	#######################################################################
	87	################ OPERACIONES DOMINIO DEL TIEMPO########################
	88	#######################################################################
	89
	90	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	91
	92	#
	93	# 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,'+\
	94	# '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'
	95
	96	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	97	#opObj11.addParameter(name='frequency', value='70312500')
	98	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	99	opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO QUE LA VELOCIDAD ES 10 GRADOS
	100	opObj11.addParameter(name='removeDC', value=1, format='int')
	101
	102
	103	#######################################################################
	104	########## OPERACIONES ParametersProc########################
	105	#######################################################################
	106
	107	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	108	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	109	opObj10.addParameter(name='path',value=path_pp)
	110	#opObj10.addParameter(name='mode',value=0)
	111	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	112	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	113	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	114
	115	controllerObj.start()

schainpy/scripts/spec_momentos_proc.py created 644 +88 0

@@ -0,0 +1,88
	1	#!python
	2
	3	import os, sys
	4	import datetime
	5	import time
	6
	7	from schainpy.controller import Project
	8
	9	desc = "USRP_test"
	10	filename = "USRP_processing.xml"
	11	controllerObj = Project()
	12	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	13
	14	############## USED TO PLOT IQ VOLTAGE, POWER AND SPECTRA #############
	15
	16	#######################################################################
	17	######PATH DE LECTURA, ESCRITURA, GRAFICOS Y ENVIO WEB#################
	18	#######################################################################
	19
	20	path = '/DATA_RM/TEST_19OCTUBRE/10MHZ'
	21	#path_pp = '/DATA_RM/TEST_HDF5'
	22	path_pp = '/DATA_RM/TEST_HDF5_19OCT'
	23
	24	#######################################################################
	25	################# RANGO DE PLOTEO######################################
	26	#######################################################################
	27	dBmin = '-5'
	28	dBmax = '20'
	29	xmin = '0'
	30	xmax ='24'
	31	ymin = '0'
	32	ymax = '600'
	33	#######################################################################
	34	########################FECHA##########################################
	35	#######################################################################
	36	str = datetime.date.today()
	37	today = str.strftime("%Y/%m/%d")
	38	str2 = str - datetime.timedelta(days=1)
	39	yesterday = str2.strftime("%Y/%m/%d")
	40	#######################################################################
	41	######################## UNIDAD DE LECTURA#############################
	42	#######################################################################
	43	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	44	path=path,
	45	startDate="2021/01/01",#today,
	46	endDate="2021/12/30",#today,
	47	startTime='00:00:00',
	48	endTime='23:59:59',
	49	delay=0,
	50	#set=0,
	51	online=0,
	52	walk=1,
	53	ippKm = 60)
	54
	55	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	56	#opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock')
	57	#######################################################################
	58	################ OPERACIONES DOMINIO DEL TIEMPO########################
	59	#######################################################################
	60	V=10 # aca se coloca la velocidad
	61	IPP=400*1e-6
	62	n= int(1/(V*IPP))
	63	print("n numero de Perfiles a procesar con nFFTPoints ", n)
	64
	65	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	66
	67	procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	68	procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
	69	procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
	70
	71	#######################################################################
	72	########## OPERACIONES ParametersProc########################
	73	#######################################################################
	74
	75	procUnitConfObjC= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
	76
	77	procUnitConfObjC.addOperation(name='SpectralMoments')
	78
	79	opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
	80	opObj10.addParameter(name='path',value=path_pp)
	81	#opObj10.addParameter(name='mode',value=0)
	82	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	83	#opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
	84	opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
	85
	86	opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
	87
	88	controllerObj.start()

schainpy/scripts/test_wradlib.py created 644 +36 0

@@ -0,0 +1,36
	1	import numpy as np
	2	import matplotlib.pyplot as pl
	3	import wradlib
	4	import warnings
	5	#export WRADLIB_DATA=/path/to/wradlib-data
	6	warnings.filterwarnings('ignore')
	7	'''
	8	try:
	9	get_ipython().magic('matplotlib inline')
	10	except:
	11	pl.ion()
	12	'''
	13	filename = wradlib.util.get_wradlib_data_file("/home/soporte/Downloads/raa00-dx_10908-0806021735-fbg---bin.gz")
	14	img, meta = wradlib.io.read_dx(filename)
	15	print("Shape of polar array: %r\n" % (img.shape,))
	16	print("Some meta data of the DX file:")
	17	print("\tdatetime: %r" % (meta["datetime"],))
	18	print("\tRadar ID: %s" % (meta["radarid"],))
	19
	20	img[200:250,:]= np.ones([50,img.shape[1]])*np.nan
	21
	22	img[300:360,:]= np.ones([60,img.shape[1]])*np.nan
	23
	24	cgax, pm= wradlib.vis.plot_ppi(img)
	25	txt = pl.title('Simple PPI')
	26	print("coordenada angular",img[:,0],len(img[:,0]))
	27	print("COORDENADA 0",img[0],len(img[0]))
	28	cbar = pl.gcf().colorbar(pm, pad=0.075)
	29
	30	#r = np.arange(40, 80)
	31	#az = np.arange(200, 250)
	32	#ax, pm = wradlib.vis.plot_ppi(img[200:250, 40:80], r, az, autoext=False)
	33	#ax, pm = wradlib.vis.plot_ppi(img[200:250, 40:80], r, az)
	34
	35	#txt = pl.title('Sector PPI')
	36	pl.show()

schainpy/sophy_test0001.py created 644 +17 0

@@ -0,0 +1,17
	1	# Ing. AVP
	2	# 01/11/2021
	3	# ARCHIVO DE LECTURA
	4	import os, sys
	5	import datetime
	6	import time
	7	from schainpy.controller import Project
	8	print("----[Setup]-RadarMeteorologico--------")
	9	Vel = 6
	10	modo_proc = 1
	11	path = "/DATA_RM/10"
	12	path_ped = "/DATA_RM/TEST_PEDESTAL/P20211111-173856"
	13	print("----[OPCIONES]------------------------")
	14	op_plot = 0
	15	op_integration = 0
	16	op_save = 0
	17	op_plot_spec = 0

schainpy/model/graphics/jroplot_parameters.py +116 -28

             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 = 10*numpy.log10(self.z)
                     self.z = numpy.ma.masked_invalid(self.z)
                     if self.decimation is None:
                         x, y, z = self.fill_gaps(self.x, self.y, self.z)
                     else:
                         x, y, z = self.fill_gaps(*self.decimate())
                     for n, ax in enumerate(self.axes):
                         self.zmax = self.zmax if self.zmax is not None else numpy.max(
                             self.z[n])
                         self.zmin = self.zmin if self.zmin is not None else numpy.min(
                             self.z[n])
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(x, y, z[n].T * self.factors[n],
                                                    vmin=self.zmin,
                                                    vmax=self.zmax,
                                                    cmap=self.cmaps[n]
                                                    )
             class PolarMapPlot(Plot):
                 '''
                 Plot for weather radar
                 '''
                 CODE = 'param'
                 colormap = 'seismic'
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.width = 9
                     self.height = 8
                     self.mode = self.data.meta['mode']
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.nrows = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.nrows = self.nplots
                         self.channels = list(range(self.nplots))
                     if self.mode == 'E':
                         self.xlabel = 'Longitude'
                         self.ylabel = 'Latitude'
                     else:
                         self.xlabel = 'Range (km)'
                         self.ylabel = 'Height (km)'
                     self.bgcolor = 'white'
                     self.cb_labels = self.data.meta['units']
                     self.lat = self.data.meta['latitude']
                     self.lon = self.data.meta['longitude']
                     self.xmin, self.xmax = float(
                         km2deg(self.xmin) + self.lon), float(km2deg(self.xmax) + self.lon)
                     self.ymin, self.ymax = float(
                         km2deg(self.ymin) + self.lat), float(km2deg(self.ymax) + self.lat)
                     #  self.polar = True
                 def plot(self):
                     for n, ax in enumerate(self.axes):
                         data = self.data['param'][self.channels[n]]
                         zeniths = numpy.linspace(
 , self.data.meta['max_range'], data.shape[1])
                         if self.mode == 'E':
                             azimuths = -numpy.radians(self.data.yrange)+numpy.pi/2
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(self.data.meta['elevation'])), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(self.data.meta['elevation']))
                             x = km2deg(x) + self.lon
                             y = km2deg(y) + self.lat
                         else:
                             azimuths = numpy.radians(self.data.yrange)
                             r, theta = numpy.meshgrid(zeniths, azimuths)
                             x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         self.y = zeniths
                         if ax.firsttime:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         else:
                             if self.zlimits is not None:
                                 self.zmin, self.zmax = self.zlimits[n]
                             ax.collections.remove(ax.collections[0])
                             ax.plt = ax.pcolormesh(  # r, theta, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 x, y, numpy.ma.array(data, mask=numpy.isnan(data)),
                                 vmin=self.zmin,
                                 vmax=self.zmax,
                                 cmap=self.cmaps[n])
                         if self.mode == 'A':
                             continue
                         # plot district names
                         f = open('/data/workspace/schain_scripts/distrito.csv')
                         for line in f:
                             label, lon, lat = [s.strip() for s in line.split(',') if s]
                             lat = float(lat)
                             lon = float(lon)
                             # ax.plot(lon, lat, '.b', ms=2)
                             ax.text(lon, lat, label.decode('utf8'), ha='center',
                                     va='bottom', size='8', color='black')
                         # plot limites
                         limites = []
                         tmp = []
                         for line in open('/data/workspace/schain_scripts/lima.csv'):
                             if '#' in line:
                                 if tmp:
                                     limites.append(tmp)
                                 tmp = []
                                 continue
                             values = line.strip().split(',')
                             tmp.append((float(values[0]), float(values[1])))
                         for points in limites:
                             ax.add_patch(
                                 Polygon(points, ec='k', fc='none', ls='--', lw=0.5))
                         # plot Cuencas
                         for cuenca in ('rimac', 'lurin', 'mala', 'chillon', 'chilca', 'chancay-huaral'):
                             f = open('/data/workspace/schain_scripts/{}.csv'.format(cuenca))
                             values = [line.strip().split(',') for line in f]
                             points = [(float(s[0]), float(s[1])) for s in values]
                             ax.add_patch(Polygon(points, ec='b', fc='none'))
                         # plot grid
                         for r in (15, 30, 45, 60):
                             ax.add_artist(plt.Circle((self.lon, self.lat),
                                                      km2deg(r), color='0.6', fill=False, lw=0.2))
                             ax.text(
                                 self.lon + (km2deg(r))*numpy.cos(60*numpy.pi/180),
                                 self.lat + (km2deg(r))*numpy.sin(60*numpy.pi/180),
                                 '{}km'.format(r),
                                 ha='center', va='bottom', size='8', color='0.6', weight='heavy')
                     if self.mode == 'E':
                         title = 'El={}$^\circ$'.format(self.data.meta['elevation'])
                         label = 'E{:02d}'.format(int(self.data.meta['elevation']))
                     else:
                         title = 'Az={}$^\circ$'.format(self.data.meta['azimuth'])
                         label = 'A{:02d}'.format(int(self.data.meta['azimuth']))
                     self.save_labels = ['{}-{}'.format(lbl, label) for lbl in self.labels]
                     self.titles = ['{} {}'.format(
                         self.data.parameters[x], title) for x in self.channels]
             class WeatherPlot(Plot):
                 CODE = 'weather'
                 plot_name = 'weather'
                 plot_type = 'ppistyle'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.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
+                    self.last_data_azi = None
+                    self.val_mean      = None
                 def update(self, dataOut):
                     data = {}
                     meta = {}
                     if hasattr(dataOut, 'dataPP_POWER'):
                         factor = 1
                     if hasattr(dataOut, 'nFFTPoints'):
                         factor = dataOut.normFactor
                     ####print("factor",factor)
-                    data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(factor))
+                    data['weather'] = 10*numpy.log10(dataOut.data_360[1]/(factor))
-                    print("weather",data['weather'])
+                    ####print("weather",data['weather'])
                     data['azi']     = dataOut.data_azi
                     return data, meta
+                def analizeDATA(self,data_azi):
+                    list1 = []
+                    list2 = []
+                    dat   = data_azi
+                    for i in reversed(range(1,len(dat))):
+                        if dat[i]>dat[i-1]:
+                            diff = int(dat[i])-int(dat[i-1])
+                        else:
+                            diff = 360+int(dat[i])-int(dat[i-1])
+                        if diff > 1:
+                            list1.append(i-1)
+                            list2.append(diff-1)
+                    return list1,list2
+                def fixDATANEW(self,data_azi,data_weather):
+                    list1,list2 = self.analizeDATA(data_azi)
+                    if len(list1)== 0:
+                        return data_azi,data_weather
+                    else:
+                        resize = 0
+                        for i in range(len(list2)):
+                            resize=  resize + list2[i]
+                        new_data_azi = numpy.resize(data_azi,resize)
+                        new_data_weather= numpy.resize(date_weather,resize)
+                        for i in range(len(list2)):
+                            j=0
+                            position=list1[i]+1
+                            for j in range(list2[i]):
+                                new_data_azi[position+j]=new_data_azi[position+j-1]+1
+                    return new_data_azi
+                def fixDATA(self,data_azi):
+                    data=data_azi
+                    for i in range(len(data)):
+                        if numpy.isnan(data[i]):
+                           data[i]=data[i-1]+1
+                    return data
+                def replaceNAN(self,data_weather,data_azi,val):
+                    print("----------------activeNEWFUNCTION")
+                    data= data_azi
+                    data_T= data_weather
+                    print("data_azi",data_azi)
+                    print("VAL:",val)
+                    print("SHAPE",data_T.shape)
+                    for i in range(len(data)):
+                        if numpy.isnan(data[i]):
+                           print("NAN")
+                           data_T[i,:]=numpy.ones(data_T.shape[1])*val
+                           #data_T[i,:]=numpy.ones(data_T.shape[1])*numpy.nan
+                    return data_T
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     if self.ini==0:
                         #------- AZIMUTH
                         n     = (360/res)-len(data_azi)
-                        start = data_azi[-1] + res
+                        ##### new
-                        end   = data_azi[0]  - res
+                        data_azi_old  = data_azi
+                        data_azi_new  = self.fixDATA(data_azi)
+                        #ata_azi_new   = self.fixDATANEW(data_azi)
+                        start = data_azi_new[-1] + res
+                        end   = data_azi_new[0]  - res
+                        ##### new
+                        self.last_data_azi = end
                         if start>end:
                             end        = end + 360
                         azi_vacia = numpy.linspace(start,end,int(n))
                         azi_vacia = numpy.where(azi_vacia>360,azi_vacia-360,azi_vacia)
-                        data_azi  = numpy.hstack((data_azi,azi_vacia))
+                        data_azi  = numpy.hstack((data_azi_new,azi_vacia))
                         # RADAR
-                        val_mean         = numpy.mean(data_weather[:,0])
+                        val_mean         = numpy.mean(data_weather[:,-1])
+                        self.val_mean    = val_mean
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
+                        data_weather     = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
+                        #### new
+                        data_azi_old = data_azi
+                        ### weather ###
+                        data_weather = self.replaceNAN(data_weather=data_weather,data_azi=data_azi_old,val=self.val_mean)
+                        if numpy.isnan(data_azi[0]):
+                            data_azi[0]=self.last_data_azi+1
+                        data_azi = self.fixDATA(data_azi)
+                        ####
                         start = data_azi[0]
                         end   = data_azi[-1]
-                        print("start",start)
+                        self.last_data_azi= end
-                        print("end",end)
+                        ####print("start",start)
+                        ####print("end",end)
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
-                        print("start",start)
+                        ####print("start",start)
-                        print("end",end)
+                        ####print("end",end)
                         #### AQUI SERA LA MAGIA
                         pos_ini = int((start-start_azi)/res)
                         len_azi = len(data_azi)
                         if (360-pos_ini)<len_azi:
                             if pos_ini+1==360:
                                 pos_ini=0
                             else:
                                 flag=1
                                 dif= 360-pos_ini
                                 comp= len_azi-dif
-                        print(pos_ini)
+                        #-----------------
-                        print(len_azi)
+                        ####print(pos_ini)
-                        print("shape",self.res_azi.shape)
+                        ####print(len_azi)
+                        ####print("shape",self.res_azi.shape)
                         if flag==0:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+len_azi] = data_azi
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+len_azi,:] = data_weather
                         else:
                             # AZIMUTH
                             self.res_azi[pos_ini:pos_ini+dif] = data_azi[0:dif]
                             self.res_azi[0:comp]              = data_azi[dif:]
                             # RADAR
                             self.res_weather[pos_ini:pos_ini+dif,:] = data_weather[0:dif,:]
                             self.res_weather[0:comp,:]              = data_weather[dif:,:]
                             flag=0
                         data_azi                                    = self.res_azi
                         data_weather                                = self.res_weather
                     return data_weather,data_azi
                 def plot(self):
-                    print("--------------------------------------",self.ini,"-----------------------------------")
+                    #print("--------------------------------------",self.ini,"-----------------------------------")
                     #numpy.set_printoptions(suppress=True)
-                    #print(self.data.times)
+                    ####print("times: ",self.data.times)
-                    thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
+                    thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1]).strftime('%Y-%m-%d %H:%M:%S')
+                    #print("times: ",thisDatetime)
                     data         = self.data[-1]
-                    # ALTURA altura_tmp_h
+                    ####ALTURA altura_tmp_h
-                    altura_h     = (data['weather'].shape[1])/10.0
+                    ###print("Y RANGES",self.data.yrange,len(self.data.yrange))
-                    stoprange = float(altura_h*1.5)#stoprange = float(33*1.5) por ahora 400
+                    ###altura_h     = (data['weather'].shape[1])/10.0
-                    rangestep = float(0.15)
+                    ###stoprange = float(altura_h*0.3)#stoprange = float(33*1.5) por ahora 400
-                    r      = numpy.arange(0, stoprange, rangestep)
+                    ###rangestep = float(0.03)
+                    ###r      = numpy.arange(0, stoprange, rangestep)
+                    ###print("r",r,len(r))
+                    #-----------------------------update----------------------
+                    r=  self.data.yrange
+                    delta_height = r[1]-r[0]
+                    #print("1",r)
+                    r_mask= numpy.where(r>=0)[0]
+                    r = numpy.arange(len(r_mask))*delta_height
+                    #print("2",r)
                     self.y = 2*r
+                    ######self.y = self.data.yrange
                     # RADAR
                     #data_weather = data['weather']
                     # PEDESTAL
                     #data_azi  = data['azi']
                     res     = 1
                     # STEP
                     step    = (360/(res*data['weather'].shape[0]))
                     #print("shape wr_data", wr_data.shape)
                     #print("shape wr_azi",wr_azi.shape)
                     #print("step",step)
-                    print("Time---->",self.data.times[-1],thisDatetime)
+                    ####print("Time---->",self.data.times[-1],thisDatetime)
-                    #print("alturas", len(self.y))
+                    #print("alturas", len(self.y))numpy.where(r>=0)
-                    self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'],data_azi=data['azi'],step=step,res=res)
+                    self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'][:,r_mask],data_azi=data['azi'],step=step,res=res)
                     #numpy.set_printoptions(suppress=True)
                     #print("resultado",self.res_azi)
-                    ##########################################################
+                    ###########################/DATA_RM/10_tmp/ch0###############################
                     #################    PLOTEO           ###################
                     ##########################################################
                     for i,ax in enumerate(self.axes):
                         if ax.firsttime:
                             plt.clf()
-                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
+                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
                         else:
                             plt.clf()
-                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=1, vmax=60)
+                            cgax, pm = wrl.vis.plot_ppi(self.res_weather,r=r,az=self.res_azi,fig=self.figures[0], proj='cg', vmin=8, vmax=35)
                     caax = cgax.parasites[0]
                     paax = cgax.parasites[1]
                     cbar = plt.gcf().colorbar(pm, pad=0.075)
                     caax.set_xlabel('x_range [km]')
                     caax.set_ylabel('y_range [km]')
-                    plt.text(1.0, 1.05, 'azimuth '+str(thisDatetime)+"step"+str(self.ini), transform=caax.transAxes, va='bottom',ha='right')
+                    plt.text(1.0, 1.05, 'azimuth '+str(thisDatetime)+"  step   "+str(self.ini), transform=caax.transAxes, va='bottom',ha='right')
                     self.ini= self.ini+1

schainpy/model/io/jroIO_digitalRF.py +1 -1

             '''
             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(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)
+                    ##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.__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[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)
                             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/io/jroIO_param.py +63 -41

             import os
             import time
             import datetime
             import numpy
             import h5py
             import schainpy.admin
             from schainpy.model.data.jrodata import *
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.io.jroIO_base import *
             from schainpy.utils import log
             class HDFReader(Reader, ProcessingUnit):
                 """Processing unit to read HDF5 format files
                 This unit reads HDF5 files created with `HDFWriter` operation contains
                 by default two groups Data and Metadata all variables would be saved as `dataOut`
                 attributes.
                 It is possible to read any HDF5 file by given the structure in the `description`
                 parameter, also you can add extra values to metadata with the parameter `extras`.
                 Parameters:
                 -----------
                 path : str
                     Path where files are located.
                 startDate : date
                     Start date of the files
                 endDate : list
                     End date of the files
                 startTime : time
                     Start time of the files
                 endTime : time
                     End time of the files
                 description : dict, optional
                     Dictionary with the description of the HDF5 file
                 extras : dict, optional
                     Dictionary with extra metadata to be be added to `dataOut`
                 Examples
                 --------
                 desc = {
                     'Data': {
                         'data_output': ['u', 'v', 'w'],
                         'utctime': 'timestamps',
                     }  ,
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 extras = {
                     'timeZone': 300
                 }
                 reader = project.addReadUnit(
                     name='HDFReader',
                     path='/path/to/files',
                     startDate='2019/01/01',
                     endDate='2019/01/31',
                     startTime='00:00:00',
                     endTime='23:59:59',
                     # description=json.dumps(desc),
                     # extras=json.dumps(extras),
                     )
                 """
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'description', 'extras']
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Parameters()
                     self.ext = ".hdf5"
                     self.optchar = "D"
                     self.meta = {}
                     self.data = {}
                     self.open_file = h5py.File
                     self.open_mode = 'r'
                     self.description = {}
                     self.extras = {}
                     self.filefmt = "*%Y%j***"
                     self.folderfmt = "*%Y%j"
                     self.utcoffset = 0
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata()
                     self.__readData()
                     self.__setBlockList()
                     if 'type' in self.meta:
                         self.dataOut = eval(self.meta['type'])()
                     for attr in self.meta:
                         setattr(self.dataOut, attr, self.meta[attr])
                     self.blockIndex = 0
                     return
                 def __setBlockList(self):
                     '''
                     Selects the data within the times defined
                     self.fp
                     self.startTime
                     self.endTime
                     self.blockList
                     self.blocksPerFile
                     '''
                     startTime = self.startTime
                     endTime = self.endTime
                     thisUtcTime = self.data['utctime'] + self.utcoffset
                     self.interval = numpy.min(thisUtcTime[1:] - thisUtcTime[:-1])
                     thisDatetime = datetime.datetime.utcfromtimestamp(thisUtcTime[0])
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     startUtcTime = (datetime.datetime.combine(thisDate, startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     endUtcTime = (datetime.datetime.combine(thisDate, endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     ind = numpy.where(numpy.logical_and(thisUtcTime >= startUtcTime, thisUtcTime < endUtcTime))[0]
                     self.blockList = ind
                     self.blocksPerFile = len(ind)
                     return
                 def __readMetadata(self):
                     '''
                     Reads Metadata
                     '''
                     meta = {}
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name][()]
                     if self.extras:
                         for key, value in self.extras.items():
                             meta[key] = value
                     self.meta = meta
                     return
                 def __readData(self):
                     data = {}
                     if self.description:
                         for key, value in self.description['Data'].items():
                             if isinstance(value, str):
                                 if isinstance(self.fp[value], h5py.Dataset):
                                     data[key] = self.fp[value][()]
                                 elif isinstance(self.fp[value], h5py.Group):
                                     array = []
                                     for ch in self.fp[value]:
                                         array.append(self.fp[value][ch][()])
                                     data[key] = numpy.array(array)
                             elif isinstance(value, list):
                                 array = []
                                 for ch in value:
                                     array.append(self.fp[ch][()])
                                 data[key] = numpy.array(array)
                     else:
                         grp = self.fp['Data']
                         for name in grp:
                             if isinstance(grp[name], h5py.Dataset):
                                 array = grp[name][()]
                             elif isinstance(grp[name], h5py.Group):
                                 array = []
                                 for ch in grp[name]:
                                     array.append(grp[name][ch][()])
                                 array = numpy.array(array)
                             else:
                                 log.warning('Unknown type: {}'.format(name))
                             if name in self.description:
                                 key = self.description[name]
                             else:
                                 key = name
                             data[key] = array
                     self.data = data
                     return
                 def getData(self):
                     for attr in self.data:
                         if self.data[attr].ndim == 1:
                             setattr(self.dataOut, attr, self.data[attr][self.blockIndex])
                         else:
                             setattr(self.dataOut, attr, self.data[attr][:, self.blockIndex])
                     self.dataOut.flagNoData = False
                     self.blockIndex += 1
                     log.log("Block No. {}/{} -> {}".format(
                         self.blockIndex,
                         self.blocksPerFile,
                         self.dataOut.datatime.ctime()), self.name)
                     return
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.blockIndex == self.blocksPerFile:
                         self.setNextFile()
                     self.getData()
                     return
             @MPDecorator
             class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                 The HDF5 file contains by default two groups Data and Metadata where
                 you can save any `dataOut` attribute specified by `dataList` and `metadataList`
                 parameters, data attributes are normaly time dependent where the metadata
                 are not.
                 It is possible to customize the structure of the HDF5 file with the
                 optional description parameter see the examples.
                 Parameters:
                 -----------
                 path : str
                     Path where files will be saved.
                 blocksPerFile : int
                     Number of blocks per file
                 metadataList : list
                     List of the dataOut attributes that will be saved as metadata
                 dataList : int
                     List of the dataOut attributes that will be saved as data
                 setType : bool
                     If True the name of the files corresponds to the timestamp of the data
                 description : dict, optional
                     Dictionary with the desired description of the HDF5 file
                 Examples
                 --------
                 desc = {
                     'data_output': {'winds': ['z', 'w', 'v']},
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'data_output': ['z', 'w', 'v'],
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 writer = proc_unit.addOperation(name='HDFWriter')
                 writer.addParameter(name='path', value='/path/to/file')
                 writer.addParameter(name='blocksPerFile', value='32')
                 writer.addParameter(name='metadataList', value='heightList,timeZone')
                 writer.addParameter(name='dataList',value='data_output,utctime')
                 # writer.addParameter(name='description',value=json.dumps(desc))
                 """
                 ext = ".hdf5"
                 optchar = "D"
                 filename = None
                 path = None
                 setFile = None
                 fp = None
                 firsttime = True
                 #Configurations
                 blocksPerFile = None
                 blockIndex = None
                 dataOut = None
                 #Data Arrays
                 dataList = None
                 metadataList = None
                 currentDay = None
                 lastTime = None
+                last_Azipos = None
+                last_Elepos = None
+                mode       = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
+                def generalFlag(self):
+                    print("GENERALFLAG")
+                    if self.mode== "weather":
+                        if self.last_Azipos == None:
+                            tmp = self.dataOut.azimuth
+                            print("ang azimuth writer",tmp)
+                            self.last_Azipos = tmp
+                            flag = False
+                            return flag
+                        print("ang_azimuth writer",self.dataOut.azimuth)
+                        result = self.dataOut.azimuth - self.last_Azipos
+                        self.last_Azipos = self.dataOut.azimuth
+                        if result<0:
+                            flag = True
+                            return flag
                 def setup(self, path=None, blocksPerFile=10, metadataList=None, dataList=None, setType=None, description=None):
                     self.path = path
                     self.blocksPerFile = blocksPerFile
                     self.metadataList = metadataList
                     self.dataList = [s.strip() for s in dataList]
                     self.setType = setType
                     self.description = description
                     if self.metadataList is None:
                         self.metadataList = self.dataOut.metadata_list
                     tableList = []
                     dsList = []
                     for i in range(len(self.dataList)):
                         dsDict = {}
                         if hasattr(self.dataOut, self.dataList[i]):
                             dataAux = getattr(self.dataOut, self.dataList[i])
                             dsDict['variable'] = self.dataList[i]
                         else:
                             log.warning('Attribute {} not found in dataOut', self.name)
                             continue
                         if dataAux is None:
                             continue
                         elif isinstance(dataAux, (int, float, numpy.integer, numpy.float)):
                             dsDict['nDim'] = 0
                         else:
                             dsDict['nDim'] = len(dataAux.shape)
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                             dsDict['dtype'] = dataAux.dtype
                         dsList.append(dsDict)
                     self.dsList = dsList
                     self.currentDay = self.dataOut.datatime.date()
                 def timeFlag(self):
                     currentTime = self.dataOut.utctime
                     timeTuple = time.localtime(currentTime)
                     dataDay = timeTuple.tm_yday
                     if self.lastTime is None:
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     if dataDay != self.currentDay:
                         self.currentDay = dataDay
                         return True
                     elif timeDiff > 3*60*60:
                         self.lastTime = currentTime
                         return True
                     else:
                         self.lastTime = currentTime
                         return False
                 def run(self, dataOut, path, blocksPerFile=10, metadataList=None,
-                        dataList=[], setType=None, description={}):
+                        dataList=[], setType=None, description={},mode= None):
                     self.dataOut = dataOut
+                    self.mode    = mode
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description)
                         self.isConfig = True
                         self.setNextFile()
                     self.putData()
                     return
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     timeTuple = time.localtime(self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join(path, subfolder)
                     if os.path.exists(fullpath):
                         filesList = os.listdir(fullpath)
                         filesList = [k for k in filesList if k.startswith(self.optchar)]
                         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]):
                                 setFile = int(filen[8:11]) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 setFile = -1
                         else:
                             setFile = -1 #inicializo mi contador de seteo
                     else:
                         os.makedirs(fullpath)
                         setFile = -1 #inicializo mi contador de seteo
                     if self.setType is None:
                         setFile += 1
                         file = '%s%4.4d%3.3d%03d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     else:
                         setFile = timeTuple.tm_hour*60+timeTuple.tm_min
                         file = '%s%4.4d%3.3d%04d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     self.filename = os.path.join( path, subfolder, file )
                     #Setting HDF5 File
                     self.fp = h5py.File(self.filename, 'w')
                     #write metadata
                     self.writeMetadata(self.fp)
                     #Write data
                     self.writeData(self.fp)
                 def getLabel(self, name, x=None):
                     if x is None:
                         if 'Data' in self.description:
                             data = self.description['Data']
                             if 'Metadata' in self.description:
                                 data.update(self.description['Metadata'])
                         else:
                             data = self.description
                         if name in data:
                             if isinstance(data[name], str):
                                 return data[name]
                             elif isinstance(data[name], list):
                                 return None
                             elif isinstance(data[name], dict):
                                 for key, value in data[name].items():
                                     return key
                         return name
                     else:
                         if 'Metadata' in self.description:
                             meta = self.description['Metadata']
                         else:
                             meta = self.description
                         if name in meta:
                             if isinstance(meta[name], list):
                                 return meta[name][x]
                             elif isinstance(meta[name], dict):
                                 for key, value in meta[name].items():
                                     return value[x]
                         if 'cspc' in name:
                             return 'pair{:02d}'.format(x)
                         else:
                             return 'channel{:02d}'.format(x)
                 def writeMetadata(self, fp):
                     if self.description:
                         if 'Metadata' in self.description:
                             grp = fp.create_group('Metadata')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Metadata')
                     for i in range(len(self.metadataList)):
                         if not hasattr(self.dataOut, self.metadataList[i]):
                             log.warning('Metadata: `{}` not found'.format(self.metadataList[i]), self.name)
                             continue
                         value = getattr(self.dataOut, self.metadataList[i])
                         if isinstance(value, bool):
                             if value is True:
                                 value = 1
                             else:
                                 value = 0
                         grp.create_dataset(self.getLabel(self.metadataList[i]), data=value)
                     return
                 def writeData(self, fp):
                     if self.description:
                         if 'Data' in self.description:
                             grp = fp.create_group('Data')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Data')
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
                                 (self.blocksPerFile, ),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                         else:
                             label = self.getLabel(dsInfo['variable'])
                             if label is not None:
                                 sgrp = grp.create_group(label)
                             else:
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
                                     (self.blocksPerFile, ) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                                 dtsets.append(ds)
                                 data.append((dsInfo['variable'], i))
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True
                     self.blockIndex = 0
                     return
                 def putData(self):
+                    print("**************************PUT DATA***************************************************")
-                    if (self.blockIndex == self.blocksPerFile) or self.timeFlag():
+                    if (self.blockIndex == self.blocksPerFile) or self.timeFlag() or self.generalFlag():
                         self.closeFile()
                         self.setNextFile()
                     for i, ds in enumerate(self.ds):
                         attr, ch = self.data[i]
                         if ch == -1:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)
                         else:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)[ch]
                     self.fp.flush()
                     self.blockIndex += 1
                     log.log('Block No. {}/{}'.format(self.blockIndex, self.blocksPerFile), self.name)
                     return
                 def closeFile(self):
                     if self.blockIndex != self.blocksPerFile:
                         for ds in self.ds:
                             ds.resize(self.blockIndex, axis=0)
                     if self.fp:
                         self.fp.flush()
                         self.fp.close()
                 def close(self):
                     self.closeFile()

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/utils/scp.py +1 -1

             # scp.py
             # Copyright (C) 2008 James Bardin <j.bardin@gmail.com>
             """
             Utilities for sending files over ssh using the scp1 protocol.
             """
             __version__ = '0.10.0'
             import locale
             import os
             import re
             from socket import timeout as SocketTimeout
             # this is quote from the shlex module, added in py3.3
             _find_unsafe = re.compile(br'[^\w@%+=:,./~-]').search
             def _sh_quote(s):
                 """Return a shell-escaped version of the string `s`."""
                 if not s:
                     return b""
                 if _find_unsafe(s) is None:
                     return s
                 # use single quotes, and put single quotes into double quotes
                 # the string $'b is then quoted as '$'"'"'b'
                 return b"'" + s.replace(b"'", b"'\"'\"'") + b"'"
             # Unicode conversion functions; assume UTF-8
             def asbytes(s):
                 """Turns unicode into bytes, if needed.
                 Assumes UTF-8.
                 """
                 if isinstance(s, bytes):
                     return s
                 else:
                     return s.encode('utf-8')
             def asunicode(s):
                 """Turns bytes into unicode, if needed.
                 Uses UTF-8.
                 """
                 if isinstance(s, bytes):
                     return s.decode('utf-8', 'replace')
                 else:
                     return s
             # os.path.sep is unicode on Python 3, no matter the platform
             bytes_sep = asbytes(os.path.sep)
             # Unicode conversion function for Windows
             # Used to convert local paths if the local machine is Windows
             def asunicode_win(s):
                 """Turns bytes into unicode, if needed.
                 """
                 if isinstance(s, bytes):
                     return s.decode(locale.getpreferredencoding())
                 else:
                     return s
             class SCPClient(object):
                 """
                 An scp1 implementation, compatible with openssh scp.
                 Raises SCPException for all transport related errors. Local filesystem
                 and OS errors pass through.
                 Main public methods are .put and .get
                 The get method is controlled by the remote scp instance, and behaves
                 accordingly. This means that symlinks are resolved, and the transfer is
                 halted after too many levels of symlinks are detected.
                 The put method uses os.walk for recursion, and sends files accordingly.
                 Since scp doesn't support symlinks, we send file symlinks as the file
                 (matching scp behaviour), but we make no attempt at symlinked directories.
                 """
                 def __init__(self, transport, buff_size=16384, socket_timeout=5.0,
                              progress=None, sanitize=_sh_quote):
                     """
                     Create an scp1 client.
                     @param transport: an existing paramiko L{Transport}
                     @type transport: L{Transport}
                     @param buff_size: size of the scp send buffer.
                     @type buff_size: int
                     @param socket_timeout: channel socket timeout in seconds
                     @type socket_timeout: float
                     @param progress: callback - called with (filename, size, sent) during
                         transfers
                     @param sanitize: function - called with filename, should return
                         safe or escaped string.  Uses _sh_quote by default.
                     @type progress: function(string, int, int)
                     """
                     self.transport = transport
                     self.buff_size = buff_size
                     self.socket_timeout = socket_timeout
                     self.channel = None
                     self.preserve_times = False
                     self._progress = progress
                     self._recv_dir = b''
                     self._rename = False
                     self._utime = None
                     self.sanitize = sanitize
                     self._dirtimes = {}
                 def __enter__(self):
                     self.channel = self._open()
                     return self
                 def __exit__(self, type, value, traceback):
                     self.close()
                 def put(self, files, remote_path=b'.',
                         recursive=False, preserve_times=False):
                     """
                     Transfer files to remote host.
                     @param files: A single path, or a list of paths to be transfered.
                         recursive must be True to transfer directories.
                     @type files: string OR list of strings
                     @param remote_path: path in which to receive the files on the remote
                         host. defaults to '.'
                     @type remote_path: str
                     @param recursive: transfer files and directories recursively
                     @type recursive: bool
                     @param preserve_times: preserve mtime and atime of transfered files
                         and directories.
                     @type preserve_times: bool
                     """
                     self.preserve_times = preserve_times
                     self.channel = self._open()
                     self._pushed = 0
                     self.channel.settimeout(self.socket_timeout)
                     scp_command = (b'scp -t ', b'scp -r -t ')[recursive]
                     self.channel.exec_command(scp_command +
                                               self.sanitize(asbytes(remote_path)))
                     self._recv_confirm()
                     if not isinstance(files, (list, tuple)):
                         files = [files]
                     if recursive:
                         self._send_recursive(files)
                     else:
                         self._send_files(files)
                     self.close()
                 def get(self, remote_path, local_path='',
                         recursive=False, preserve_times=False):
                     """
                     Transfer files from remote host to localhost
                     @param remote_path: path to retreive from remote host. since this is
                         evaluated by scp on the remote host, shell wildcards and
                         environment variables may be used.
                     @type remote_path: str
                     @param local_path: path in which to receive files locally
                     @type local_path: str
                     @param recursive: transfer files and directories recursively
                     @type recursive: bool
                     @param preserve_times: preserve mtime and atime of transfered files
                         and directories.
                     @type preserve_times: bool
                     """
                     if not isinstance(remote_path, (list, tuple)):
                         remote_path = [remote_path]
                     remote_path = [self.sanitize(asbytes(r)) for r in remote_path]
                     self._recv_dir = local_path or os.getcwd()
                     self._rename = (len(remote_path) == 1 and
                                     not os.path.isdir(os.path.abspath(local_path)))
                     if len(remote_path) > 1:
                         if not os.path.exists(self._recv_dir):
                             raise SCPException("Local path '%s' does not exist" %
                                                asunicode(self._recv_dir))
                         elif not os.path.isdir(self._recv_dir):
                             raise SCPException("Local path '%s' is not a directory" %
                                                asunicode(self._recv_dir))
                     rcsv = (b'', b' -r')[recursive]
                     prsv = (b'', b' -p')[preserve_times]
                     self.channel = self._open()
                     self._pushed = 0
                     self.channel.settimeout(self.socket_timeout)
                     self.channel.exec_command(b"scp" +
                                               rcsv +
                                               prsv +
                                               b" -f " +
                                               b' '.join(remote_path))
                     self._recv_all()
                     self.close()
                 def _open(self):
                     """open a scp channel"""
                     if self.channel is None:
                         self.channel = self.transport.open_session()
                     return self.channel
                 def close(self):
                     """close scp channel"""
                     if self.channel is not None:
                         self.channel.close()
                         self.channel = None
                 def _read_stats(self, name):
                     """return just the file stats needed for scp"""
                     if os.name == 'nt':
                         name = asunicode(name)
                     stats = os.stat(name)
                     mode = oct(stats.st_mode)[-4:]
                     size = stats.st_size
                     atime = int(stats.st_atime)
                     mtime = int(stats.st_mtime)
                     return (mode, size, mtime, atime)
                 def _send_files(self, files):
                     for name in files:
                         basename = asbytes(os.path.basename(name))
                         (mode, size, mtime, atime) = self._read_stats(name)
                         if self.preserve_times:
                             self._send_time(mtime, atime)
                         file_hdl = open(name, 'rb')
                         # The protocol can't handle \n in the filename.
                         # Quote them as the control sequence \^J for now,
                         # which is how openssh handles it.
                         self.channel.sendall(("C%s %d " % (mode, size)).encode('ascii') +
                                              basename.replace(b'\n', b'\\^J') + b"\n")
                         self._recv_confirm()
                         file_pos = 0
                         if self._progress:
                             if size == 0:
                                 # avoid divide-by-zero
                                 self._progress(basename, 1, 1)
                             else:
                                 self._progress(basename, size, 0)
                         buff_size = self.buff_size
                         chan = self.channel
                         while file_pos < size:
                             chan.sendall(file_hdl.read(buff_size))
                             file_pos = file_hdl.tell()
                             if self._progress:
                                 self._progress(basename, size, file_pos)
                         chan.sendall('\x00')
                         file_hdl.close()
                         self._recv_confirm()
                 def _chdir(self, from_dir, to_dir):
                     # Pop until we're one level up from our next push.
                     # Push *once* into to_dir.
                     # This is dependent on the depth-first traversal from os.walk
                     # add path.sep to each when checking the prefix, so we can use
                     # path.dirname after
                     common = os.path.commonprefix([from_dir + bytes_sep,
                                                    to_dir + bytes_sep])
                     # now take the dirname, since commonprefix is character based,
                     # and we either have a seperator, or a partial name
                     common = os.path.dirname(common)
                     cur_dir = from_dir.rstrip(bytes_sep)
                     while cur_dir != common:
                         cur_dir = os.path.split(cur_dir)[0]
                         self._send_popd()
                     # now we're in our common base directory, so on
                     self._send_pushd(to_dir)
                 def _send_recursive(self, files):
                     for base in files:
                         if not os.path.isdir(base):
                             # filename mixed into the bunch
                             self._send_files([base])
                             continue
                         last_dir = asbytes(base)
                         for root, dirs, fls in os.walk(base):
                             self._chdir(last_dir, asbytes(root))
                             self._send_files([os.path.join(root, f) for f in fls])
                             last_dir = asbytes(root)
                         # back out of the directory
                         while self._pushed > 0:
                             self._send_popd()
                 def _send_pushd(self, directory):
                     (mode, size, mtime, atime) = self._read_stats(directory)
                     basename = asbytes(os.path.basename(directory))
                     if self.preserve_times:
                         self._send_time(mtime, atime)
                     self.channel.sendall(('D%s 0 ' % mode).encode('ascii') +
                                          basename.replace(b'\n', b'\\^J') + b'\n')
                     self._recv_confirm()
                     self._pushed += 1
                 def _send_popd(self):
                     self.channel.sendall('E\n')
                     self._recv_confirm()
                     self._pushed -= 1
                 def _send_time(self, mtime, atime):
                     self.channel.sendall(('T%d 0 %d 0\n' % (mtime, atime)).encode('ascii'))
                     self._recv_confirm()
                 def _recv_confirm(self):
                     # read scp response
                     msg = b''
                     try:
                         msg = self.channel.recv(512)
                     except SocketTimeout:
                         raise SCPException('Timout waiting for scp response')
                     # slice off the first byte, so this compare will work in py2 and py3
                     if msg and msg[0:1] == b'\x00':
                         return
                     elif msg and msg[0:1] == b'\x01':
                         raise SCPException(asunicode(msg[1:]))
                     elif self.channel.recv_stderr_ready():
                         msg = self.channel.recv_stderr(512)
                         raise SCPException(asunicode(msg))
                     elif not msg:
                         raise SCPException('No response from server')
                     else:
                         raise SCPException('Invalid response from server', msg)
                 def _recv_all(self):
                     # loop over scp commands, and receive as necessary
                     command = {b'C': self._recv_file,
                                b'T': self._set_time,
                                b'D': self._recv_pushd,
                                b'E': self._recv_popd}
                     while not self.channel.closed:
                         # wait for command as long as we're open
                         self.channel.sendall('\x00')
                         msg = self.channel.recv(1024)
                         if not msg:  # chan closed while recving
                             break
                         assert msg[-1:] == b'\n'
                         msg = msg[:-1]
                         code = msg[0:1]
                         try:
                             command[code](msg[1:])
                         except KeyError:
                             raise SCPException(asunicode(msg[1:]))
                     # directory times can't be set until we're done writing files
                     self._set_dirtimes()
                 def _set_time(self, cmd):
                     try:
                         times = cmd.split(b' ')
                         mtime = int(times[0])
                         atime = int(times[2]) or mtime
                     except:
                         self.channel.send(b'\x01')
                         raise SCPException('Bad time format')
                     # save for later
                     self._utime = (atime, mtime)
                 def _recv_file(self, cmd):
                     chan = self.channel
                     parts = cmd.strip().split(b' ', 2)
                     try:
                         mode = int(parts[0], 8)
                         size = int(parts[1])
                         if self._rename:
                             path = self._recv_dir
                             self._rename = False
                         elif os.name == 'nt':
                             path = os.path.join(asunicode_win(self._recv_dir),
                                                 parts[2].decode('utf-8'))
                         else:
                             path = os.path.join(asbytes(self._recv_dir),
                                                 parts[2])
                     except:
                         chan.send('\x01')
                         chan.close()
                         raise SCPException('Bad file format')
                     try:
                         file_hdl = open(path, 'wb')
                     except IOError as e:
                         chan.send(b'\x01' + str(e).encode('utf-8'))
                         chan.close()
                         raise
                     if self._progress:
                         if size == 0:
                             # avoid divide-by-zero
                             self._progress(path, 1, 1)
                         else:
                             self._progress(path, size, 0)
                     buff_size = self.buff_size
                     pos = 0
                     chan.send(b'\x00')
                     try:
                         while pos < size:
                             # we have to make sure we don't read the final byte
                             if size - pos <= buff_size:
                                 buff_size = size - pos
                             file_hdl.write(chan.recv(buff_size))
                             pos = file_hdl.tell()
                             if self._progress:
                                 self._progress(path, size, pos)
                         msg = chan.recv(512)
                         if msg and msg[0:1] != b'\x00':
                             raise SCPException(asunicode(msg[1:]))
                     except SocketTimeout:
                         chan.close()
                         raise SCPException('Error receiving, socket.timeout')
                     file_hdl.truncate()
                     try:
                         os.utime(path, self._utime)
                         self._utime = None
                         os.chmod(path, mode)
                         # should we notify the other end?
                     finally:
                         file_hdl.close()
                     # '\x00' confirmation sent in _recv_all
                 def _recv_pushd(self, cmd):
                     parts = cmd.split(b' ', 2)
                     try:
                         mode = int(parts[0], 8)
                         if self._rename:
                             path = self._recv_dir
                             self._rename = False
                         elif os.name == 'nt':
                             path = os.path.join(asunicode_win(self._recv_dir),
                                                 parts[2].decode('utf-8'))
                         else:
                             path = os.path.join(asbytes(self._recv_dir),
                                                 parts[2])
                     except:
                         self.channel.send(b'\x01')
                         raise SCPException('Bad directory format')
                     try:
                         if not os.path.exists(path):
                             os.mkdir(path, mode)
                         elif os.path.isdir(path):
                             os.chmod(path, mode)
                         else:
                             raise SCPException('%s: Not a directory' % path)
                         self._dirtimes[path] = (self._utime)
                         self._utime = None
                         self._recv_dir = path
                     except (OSError, SCPException) as e:
                         self.channel.send(b'\x01' + asbytes(str(e)))
                         raise
                 def _recv_popd(self, *cmd):
                     self._recv_dir = os.path.split(self._recv_dir)[0]
                 def _set_dirtimes(self):
                     try:
                         for d in self._dirtimes:
                             os.utime(d, self._dirtimes[d])
                     finally:
                         self._dirtimes = {}
             class SCPException(Exception):
                 """SCP exception class"""
-                pass
  No newline at end of file
+                pass

schainpy/scripts/basic_proc00001.py +89 -23

             # Ing. AVP
             # 06/10/2021
             # ARCHIVO DE LECTURA
             import os, sys
             import datetime
             import time
             from schainpy.controller import Project
             #### NOTA###########################################
             # INPUT :
             # VELOCIDAD PARAMETRO :        V = 2°/seg
             # MODO PULSE PAIR O MOMENTOS:  0 : Pulse Pair ,1 : Momentos
             ######################################################
             ##### PROCESAMIENTO ##################################
             #####  OJO TENER EN CUENTA EL n= para el Pulse Pair ##
             #####                   O EL n= nFFTPoints         ###
             ######################################################
             ######## BUSCAMOS EL numero de IPP equivalente 1°#####
             ######## Sea V la velocidad del Pedestal en °/seg#####
             ######## 1° sera Recorrido en un tiempo de  1/V ######
             ######## IPP del Radar 400 useg --> 60 Km ############
             ######## n   = 1/(V(°/seg)*IPP(Km)) , NUMERO DE IPP ##
             ######## n   = 1/(V*IPP) #############################
             ######## VELOCIDAD DEL PEDESTAL ######################
             print("SETUP- RADAR METEOROLOGICO")
-            V       = 10
+            V       = 6
             mode    = 1
-            #path    = '/DATA_RM/23/6v'
+            #--------------------------PATH -----------------------------
-            ####path    = '/DATA_RM/TEST_INTEGRACION_2M'
+            # path    = '/DATA_RM/23/6v'
-            #path    = '/DATA_RM/TEST_19OCTUBRE/10MHZ'
+            # path    = '/DATA_RM/TEST_INTEGRACION_2M'
-            path    = '/DATA_RM/WR_20_OCT'
+            # path    = '/DATA_RM/TEST_19OCTUBRE/10MHZ'
+            # path    = '/DATA_RM/WR_20_OCT'
             #### path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
             ####path_ped='/DATA_RM/TEST_PEDESTAL/P20211019-192244'
-            figpath_pp  = "/home/soporte/Pictures/TEST_PP"
+            #path  = '/DATA_RM/WR_POT_09_1'
-            figpath_spec = "/home/soporte/Pictures/TEST_MOM"
+            #path  = '/DATA_RM/WR_POT_09_2'
+            #path ="/DATA_RM/10"
+            #path ="/DATA_RM/11"
+            #path ="/DATA_RM/DRONE/2MHZ_6V"
+            path ="/DATA_RM/DRONE/2MHZ_10V_ELEVACION"
+            path ="/DATA_RM/DRONE/2MHZ_6V_AZIMUTH"
+            #-------------------------PATH-PLOTEO------------------------------------
+            #figpath_pp  = "/home/soporte/Pictures/TEST_PP"
+            #figpath_spec = "/home/soporte/Pictures/TEST_MOM_15"
+            #figpath_spec = "/home/soporte/Pictures/11_"
+            figpath_spec = "/home/soporte/Pictures/23NOV"
+            figpath_spec = "/home/soporte/Pictures/23NOV_TEST_AZI"
+            figpath_pp  = "/home/soporte/Pictures/TEST_POT"
+            figpath_pp  = "/home/soporte/Pictures/TEST_POT_10_"
+            #--------------------------OPCIONES-----------------------------------
             plot        = 0
-            integration = 1
+            integration = 0
             save        = 0
+            plot_spec   = 1
+            #-------------------------------------------------------------------------
             if save == 1:
                 if mode==0:
                     path_save = '/DATA_RM/TEST_HDF5_PP_23/6v'
                     path_save = '/DATA_RM/TEST_HDF5_PP'
                     path_save = '/DATA_RM/TEST_HDF5_PP_100'
                 else:
                     path_save = '/DATA_RM/TEST_HDF5_SPEC_23_V2/6v'
             print("* PATH data ADQ        :", path)
             print("* Velocidad Pedestal   :",V,"°/seg")
             ############################ NRO Perfiles PROCESAMIENTO ###################
             V=V
             IPP=400*1e-6
             n= int(1/(V*IPP))
             print("* n - NRO Perfiles Proc:", n )
             ################################## MODE ###################################
             print("* Modo de Operacion    :",mode)
             if mode ==0:
                 print("* Met. Seleccionado    : Pulse Pair")
             else:
                 print("* Met. Momentos        : Momentos")
             ################################## MODE ###################################
             print("* Grabado de datos     :",save)
             if save ==1:
                 if mode==0:
                     ope= "Pulse Pair"
                 else:
                     ope= "Momentos"
                 print("* Path-Save Data -", ope , path_save)
             print("* Integracion de datos :",integration)
-            time.sleep(15)
+            time.sleep(3)
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
-            dBmin = '1'
+            dBmin = '8'
-            dBmax = '65'
+            dBmax = '35'
-            xmin = '13.2'
+            xmin = '12.1'#17.1,17.5
-            xmax = '13.5'
+            xmax = '12.2'#17.2,17.8
-            ymin = '0'
+            ymin = '0'#### PONER A 0
-            ymax = '60'
+            ymax = '8'#### PONER A 8
             #######################################################################
             ########################FECHA##########################################
             str = datetime.date.today()
             today = str.strftime("%Y/%m/%d")
             str2 = str - datetime.timedelta(days=1)
             yesterday = str2.strftime("%Y/%m/%d")
             #######################################################################
             ########################SIGNAL CHAIN ##################################
             #######################################################################
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
-                                                        startDate="2021/01/01",#today,
+                                                        startDate="2021/11/23",#today,
-                                                        endDate="2021/12/30",#today,
+                                                        endDate="2021/12/23",#today,
-                                                        startTime='00:00:00',
+                                                        startTime='15:00:00',#'17:39:25',
-                                                        endTime='23:59:59',
+                                                        endTime='16:00:59',#23:59:59',
                                                         delay=0,
                                                         #set=0,
-                                                        online=0,
+                                                        online=1,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
             procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
+            opObj11 = procUnitConfObjA.addOperation(name='setH0')
+            opObj11.addParameter(name='h0', value='-3.3', format='float')
+            #-2.8 5MHZ
+            #-3.3 2MHZ
+            ###opObj11 = procUnitConfObjA.addOperation(name='selectChannels')
+            ###opObj11.addParameter(name='channelList', value='[1]',format='intList')
+            opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
+            opObj11.addParameter(name='minIndex', value='1', format='int')
+            ###opObj11.addParameter(name='maxIndex', value='10000', format='int')
+            opObj11.addParameter(name='maxIndex', value='160', format='int')
+            ## 400 PARA 5MHZ 12KM 2000
+            ## 160 ṔARA 2MHZ 12KM 800
             if mode ==0:
                 ####################### METODO PULSE PAIR ######################################################################
                 opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
                 opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
                 #opObj11.addParameter(name='removeDC', value=1, format='int')
                 ####################### METODO Parametros ######################################################################
                 procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
                 if plot==1:
                     opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
                     opObj11.addParameter(name='attr_data', value='dataPP_POWER')
                     opObj11.addParameter(name='colormap', value='jet')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
+                    #opObj11.addParameter(name='ymin', value=ymin)
+                    #opObj11.addParameter(name='ymax', value=ymax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_pp)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=10)
                 ####################### METODO ESCRITURA #######################################################################
                 if save==1:
                     opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='100',format='int')
                     opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
                     opObj10.addParameter(name='dataList',value='dataPP_POWER,dataPP_DOP,utctime',format='list')#,format='list'
                 if integration==1:
                     V=10
                     blocksPerfile=360
                     print("* Velocidad del Pedestal:",V)
                     tmp_blocksPerfile = 100
                     f_a_p= int(tmp_blocksPerfile/V)
                     opObj11 = procUnitConfObjB.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='blocksPerfile', value=blocksPerfile, format='int')
                     opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                     opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                     opObj11.addParameter(name='online', value='0', format='int')
                     opObj11 = procUnitConfObjB.addOperation(name='Block360')
                     opObj11.addParameter(name='n', value='10', format='int')
                     opObj11.addParameter(name='mode', value=mode, format='int')
                     # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                     opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
             else:
                 ####################### METODO SPECTROS ######################################################################
                 procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
                 procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
                 procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
+                if plot_spec==1:
+                    '''
+                    opObj11 = procUnitConfObjB.addOperation(name='SpectraPlot', optype='external')
+                    #.addParameter(name='id', value='2', format='int')
+                    opObj11.addParameter(name='wintitle', value='SpectraPlot', format='str')
+                    opObj11.addParameter(name='channelList', value='1', format='intlist')
+                    #opObj11.addParameter(name='xmin', value=xmin)
+                    #opObj11.addParameter(name='xmax', value=xmax)
+                    opObj11.addParameter(name='ymin', value=ymin)
+                    opObj11.addParameter(name='ymax', value=ymax)
+                    opObj11.addParameter(name='zmin', value=dBmin, format='int')
+                    opObj11.addParameter(name='zmax', value=dBmax, format='int')
+                    opObj11.addParameter(name='save', value=figpath_spec)
+                    opObj11.addParameter(name='showprofile', value=0)
+                    opObj11.addParameter(name='save_period', value=1)
+                    '''
+                    opObj11 = procUnitConfObjB.addOperation(name='RTIPlot', optype='external')
+                    #.addParameter(name='id', value='2', format='int')
+                    opObj11.addParameter(name='wintitle', value='RTIPlot', format='str')
+                    opObj11.addParameter(name='channelList', value='1', format='intlist')
+                    opObj11.addParameter(name='xmin', value=xmin)
+                    opObj11.addParameter(name='xmax', value=xmax)
+                    opObj11.addParameter(name='ymin', value=ymin)
+                    opObj11.addParameter(name='ymax', value=ymax)
+                    opObj11.addParameter(name='zmin', value=dBmin, format='int')
+                    opObj11.addParameter(name='zmax', value=dBmax, format='int')
+                    opObj11.addParameter(name='save', value=figpath_spec)
+                    opObj11.addParameter(name='showprofile', value=0)
+                    opObj11.addParameter(name='save_period', value=1)
                 procUnitConfObjC = controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
                 procUnitConfObjC.addOperation(name='SpectralMoments')
                 if plot==1:
-                    dBmin = '1'
-                    dBmax = '65'
                     opObj11 = procUnitConfObjC.addOperation(name='PowerPlot',optype='external')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
+                    opObj11.addParameter(name='ymin', value=ymin)
+                    opObj11.addParameter(name='ymax', value=ymax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_spec)
                     opObj11.addParameter(name='showprofile', value=0)
-                    opObj11.addParameter(name='save_period', value=10)
+                    opObj11.addParameter(name='save_period', value=1)
                 if save==1:
                     opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
                     opObj10.addParameter(name='path',value=path_save)
                     #opObj10.addParameter(name='mode',value=0)
                     opObj10.addParameter(name='blocksPerFile',value='360',format='int')
                     #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
                     opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
                 if integration==1:
                    V=10
                    blocksPerfile=360
                    print("* Velocidad del Pedestal:",V)
                    tmp_blocksPerfile = 100
                    f_a_p= int(tmp_blocksPerfile/V)
                    opObj11 = procUnitConfObjC.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='blocksPerfile', value=blocksPerfile, format='int')
                    opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                    opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                    opObj11.addParameter(name='online', value='0', format='int')
                    opObj11 = procUnitConfObjC.addOperation(name='Block360')
                    opObj11.addParameter(name='n', value='10', format='int')
                    opObj11.addParameter(name='mode', value=mode, format='int')
                    # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                    opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
             controllerObj.start()

schainpy/scripts/basic_proc00002.py +89 -37

             # Ing. AVP
             # 06/10/2021
             # ARCHIVO DE LECTURA
             import os, sys
             import datetime
             import time
             from schainpy.controller import Project
             #### NOTA###########################################
             # INPUT :
             # VELOCIDAD PARAMETRO :        V = 2°/seg
             # MODO PULSE PAIR O MOMENTOS:  0 : Pulse Pair ,1 : Momentos
             ######################################################
             ##### PROCESAMIENTO ##################################
             #####  OJO TENER EN CUENTA EL n= para el Pulse Pair ##
             #####                   O EL n= nFFTPoints         ###
             ######################################################
             ######## BUSCAMOS EL numero de IPP equivalente 1°#####
             ######## Sea V la velocidad del Pedestal en °/seg#####
             ######## 1° sera Recorrido en un tiempo de  1/V ######
             ######## IPP del Radar 400 useg --> 60 Km ############
             ######## n   = 1/(V(°/seg)*IPP(Km)) , NUMERO DE IPP ##
             ######## n   = 1/(V*IPP) #############################
             ######## VELOCIDAD DEL PEDESTAL ######################
             print("SETUP- RADAR METEOROLOGICO")
+            V       = 6
             V       = 10
-            mode    = 0
+            mode    = 1
-            #path    = '/DATA_RM/23/6v'
+            #--------------------------PATH -----------------------------
-            #path    = '/DATA_RM/TEST_INTEGRACION_2M'
+            # path    = '/DATA_RM/23/6v'
-            path    = '/DATA_RM/WR_20_OCT'
+            # path    = '/DATA_RM/TEST_INTEGRACION_2M'
+            # path    = '/DATA_RM/TEST_19OCTUBRE/10MHZ'
+            # path    = '/DATA_RM/WR_20_OCT'
+            #### path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
+            ####path_ped='/DATA_RM/TEST_PEDESTAL/P20211019-192244'
+            path ="/DATA_RM/10"
+            # path  = '/DATA_RM/WR_POT_09_1'
+            #path ="/DATA_RM/11"
+            #path ="/DATA_RM/11"
+            #-------------------------PATH-PLOTEO------------------------------------
+            #figpath_pp  = "/home/soporte/Pictures/TEST_PP"
+            #figpath_spec = "/home/soporte/Pictures/TEST_MOM"
+            figpath_spec = "/home/soporte/Pictures/ppi"
+            figpath_ppi  = "/home/soporte/Pictures/ppi_SPEC_10DIC"
+            figpath_ppi_pp  = "/home/soporte/Pictures/ppi_2_10"
+            figpath_pp  = "/home/soporte/Pictures/TEST_POT"
+            figpath_pp  = "/home/soporte/Pictures/TEST_POT2"
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
-            path_ped='/DATA_RM/TEST_PEDESTAL/P20211020-131248'
+            #path_ped='/DATA_RM/TEST_PEDESTAL/P20211020-131248'
+            #path_ped='/DATA_RM/TEST_PEDESTAL/P20211110-171003'
+            #path_ped='/DATA_RM/TEST_PEDESTAL/P20211111-173856'
+            path_ped  =  "/DATA_RM/TEST_PEDESTAL/P20211110-171003"
-            figpath_pp  = "/home/soporte/Pictures/TEST_PP"
+            figpath_pp  = "/home/soporte/Pictures/25TEST_PP"
             figpath_mom = "/home/soporte/Pictures/TEST_MOM"
+            #--------------------------OPCIONES-----------------------------------
             plot        = 0
             integration = 1
-            save        = 0
+            save        = 1
             if save == 1:
                 if mode==0:
                     path_save = '/DATA_RM/TEST_HDF5_PP_23/6v'
                     path_save = '/DATA_RM/TEST_HDF5_PP'
                     path_save = '/DATA_RM/TEST_HDF5_PP_100'
+                    path_save = '/DATA_RM/TEST_EMPTHY'
                 else:
                     path_save = '/DATA_RM/TEST_HDF5_SPEC_23_V2/6v'
+                    path_save = '/DATA_RM/TEST_EMPTHY_SPEC'
+                    path_save = '/DATA_RM/LAST_TEST_16_VACIO3'
+                    path_save = '/DATA_RM/LAST_TEST_30_360'
             print("* PATH data ADQ        :", path)
             print("* Velocidad Pedestal   :",V,"°/seg")
             ############################ NRO Perfiles PROCESAMIENTO ###################
             V=V
             IPP=400*1e-6
             n= int(1/(V*IPP))
             print("* n - NRO Perfiles Proc:", n )
             ################################## MODE ###################################
             print("* Modo de Operacion    :",mode)
             if mode ==0:
                 print("* Met. Seleccionado    : Pulse Pair")
             else:
                 print("* Met. Momentos        : Momentos")
             ################################## MODE ###################################
             print("* Grabado de datos     :",save)
             if save ==1:
                 if mode==0:
                     ope= "Pulse Pair"
                 else:
                     ope= "Momentos"
                 print("* Path-Save Data -", ope , path_save)
             print("* Integracion de datos :",integration)
-            time.sleep(5)
+            time.sleep(3)
             #remotefolder = "/home/wmaster/graficos"
             #######################################################################
             ################# RANGO DE PLOTEO######################################
             dBmin = '1'
             dBmax = '85'
-            xmin = '15'
+            xmin = '17'
-            xmax = '15.25'
+            xmax = '17.25'
             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")
             #######################################################################
             ########################SIGNAL CHAIN ##################################
             #######################################################################
             desc = "USRP_test"
             filename = "USRP_processing.xml"
             controllerObj = Project()
             controllerObj.setup(id = '191', name='Test_USRP', description=desc)
             #######################################################################
             ######################## UNIDAD DE LECTURA#############################
             #######################################################################
             readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
                                                         path=path,
-                                                        startDate="2021/01/01",#today,
+                                                        startDate="2021/11/10",#today,
                                                         endDate="2021/12/30",#today,
-                                                        startTime='00:00:00',
+                                                        startTime='17:10:25',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=1,
                                                         ippKm = 60)
             opObj11 = readUnitConfObj.addOperation(name='printInfo')
-            procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
+            procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc',inputId=readUnitConfObj.getId())
+            #opObj11 = procUnitConfObjA.addOperation(name='setH0')
+            #opObj11.addParameter(name='h0', value='-2.8', format='float')
+            opObj11 = procUnitConfObjA.addOperation(name='selectHeights')
+            opObj11.addParameter(name='minIndex', value='1', format='int')
+            #    opObj11.addParameter(name='maxIndex', value='10000', format='int')
+            opObj11.addParameter(name='maxIndex', value='400', format='int')
             if mode ==0:
                 ####################### METODO PULSE PAIR ######################################################################
                 opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
                 opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO  QUE LA VELOCIDAD ES 10 GRADOS
                 #opObj11.addParameter(name='removeDC', value=1, format='int')
                 ####################### METODO Parametros ######################################################################
                 procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
                 if plot==1:
                     opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
                     opObj11.addParameter(name='attr_data', value='dataPP_POW')
                     opObj11.addParameter(name='colormap', value='jet')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_pp)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=50)
                 ####################### METODO ESCRITURA #######################################################################
-                if save==1:
-                    opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
-                    opObj10.addParameter(name='path',value=path_save)
-                    #opObj10.addParameter(name='mode',value=0)
-                    opObj10.addParameter(name='blocksPerFile',value='100',format='int')
-                    opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
-                    opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
                 if integration==1:
-                    V=10
+                    V=V
-                    blocksPerfile=360
+                    blocksPerfile=100
                     print("* Velocidad del Pedestal:",V)
                     tmp_blocksPerfile = 100
                     f_a_p= int(tmp_blocksPerfile/V)
                     opObj11 = procUnitConfObjB.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='blocksPerfile', value=blocksPerfile, format='int')
                     opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                     opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                     opObj11.addParameter(name='online', value='0', format='int')
+                    '''
                     opObj11 = procUnitConfObjB.addOperation(name='Block360')
                     opObj11.addParameter(name='n', value='10', format='int')
                     opObj11.addParameter(name='mode', value=mode, format='int')
+                    '''
                     # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
+                    '''
                     opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
+                    opObj11.addParameter(name='save', value=figpath_ppi_pp)
+                    opObj11.addParameter(name='save_period', value=1)
+                    '''
+                if save==1:
+                    opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
+                    opObj10.addParameter(name='path',value=path_save)
+                    #opObj10.addParameter(name='mode',value=0)
+                    opObj10.addParameter(name='blocksPerFile',value='100',format='int')
+                    opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
+                    opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,azimuth,utctime',format='list')#,format='list'
             else:
                 ####################### METODO SPECTROS ######################################################################
                 procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
                 procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
                 procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
                 procUnitConfObjC = controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
                 procUnitConfObjC.addOperation(name='SpectralMoments')
                 if plot==1:
                     dBmin = '1'
                     dBmax = '65'
                     opObj11 = procUnitConfObjC.addOperation(name='PowerPlot',optype='external')
                     opObj11.addParameter(name='xmin', value=xmin)
                     opObj11.addParameter(name='xmax', value=xmax)
                     opObj11.addParameter(name='zmin', value=dBmin)
                     opObj11.addParameter(name='zmax', value=dBmax)
                     opObj11.addParameter(name='save', value=figpath_mom)
                     opObj11.addParameter(name='showprofile', value=0)
                     opObj11.addParameter(name='save_period', value=100)
-                if save==1:
-                    opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
-                    opObj10.addParameter(name='path',value=path_save)
-                    #opObj10.addParameter(name='mode',value=0)
-                    opObj10.addParameter(name='blocksPerFile',value='360',format='int')
-                    #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
-                    opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
-                    opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
                 if integration==1:
-                   V=10
+                   V=V
-                   blocksPerfile=360
+                   blocksPerfile=100
                    print("* Velocidad del Pedestal:",V)
                    tmp_blocksPerfile = 100
                    f_a_p= int(tmp_blocksPerfile/V)
                    opObj11 = procUnitConfObjC.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='blocksPerfile', value=blocksPerfile, format='int')
                    opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
                    opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
                    opObj11.addParameter(name='online', value='0', format='int')
                    opObj11 = procUnitConfObjC.addOperation(name='Block360')
-                   opObj11.addParameter(name='n', value='10', format='int')
+                   opObj11.addParameter(name='n', value='1', format='int')
                    opObj11.addParameter(name='mode', value=mode, format='int')
+                   '''
+                   # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
+                   opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
+                   opObj11.addParameter(name='save', value=figpath_ppi)
+                   opObj11.addParameter(name='save_period', value=1)
+                   '''
+                if save==1:
+                   opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
+                   opObj10.addParameter(name='path',value=path_save)
+                   opObj10.addParameter(name='mode',value='weather')
+                   opObj10.addParameter(name='blocksPerFile',value='360',format='int')
+                   #opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
+                   opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
+                   #opObj10.addParameter(name='dataList',value='data_pow,data_dop,azimuth,utctime',format='list')#,format='list'
+                   opObj10.addParameter(name='dataList',value='data_360,data_azi,utctime',format='list')#,format='list'
+                   '''
                    # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
                    opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
+                   opObj11.addParameter(name='save', value=figpath_ppi)
+                   opObj11.addParameter(name='save_period', value=1)
+                   '''
             controllerObj.start()

schainpy/scripts/check_pedestal.py +4 -1

             # Ing-AlexanderValdez
             # Monitoreo de Pedestal
             ############## IMPORTA LIBRERIAS ###################
             import os,numpy,h5py
             import sys,time
             import matplotlib.pyplot as plt
             ####################################################
             #################################################################
             # LA FECHA 21-10-20 CORRESPONDE A LAS PRUEBAS DEL DIA MIERCOLES
             # 1:15:51 pm hasta 3:49:32 pm
             #################################################################
             #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211012-082745'
             path_ped = '/DATA_RM/TEST_PEDESTAL/P20211020-131248'
+            path_ped = '/DATA_RM/TEST_PEDESTAL/P20211110-171003'
+            path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173856'
+            #path_ped = '/DATA_RM/TEST_PEDESTAL/P20211111-173409'
             # Metodo para verificar numero
             def isNumber(str):
                 try:
                     float(str)
                     return True
                 except:
                     return False
             # Metodo para extraer el arreglo
             def getDatavaluefromDirFilename(path,file,value):
                 dir_file= path+"/"+file
                 fp      = h5py.File(dir_file,'r')
                 array    = fp['Data'].get(value)[()]
                 fp.close()
                 return array
             # LISTA COMPLETA DE ARCHIVOS HDF5 Pedestal
             LIST= sorted(os.listdir(path_ped))
             m=len(LIST)
             print("TOTAL DE ARCHIVOS DE PEDESTAL:",m)
             # Contadores temporales
             k=  0
             l=  0
             t=  0
             # Marca de tiempo temporal
             time_        = numpy.zeros([m])
             # creacion de
             for i in range(m):
                 print("order:",i)
                 tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_pos")
                 tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_pos")
                 tmp_azi_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel")
                 tmp_ele_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel")# nuevo :D
                 time_[i]    = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="utc")
                 k=k +tmp_azi_pos.shape[0]
                 l=l +tmp_ele_pos.shape[0]
                 t=t +tmp_azi_vel.shape[0]
             print("TOTAL DE MUESTRAS, ARCHIVOS X100:",k)
             time.sleep(5)
             ######CREACION DE ARREGLOS CANTIDAD DE VALORES POR MUESTRA#################
             azi_pos     = numpy.zeros([k])
             ele_pos     = numpy.zeros([l])
             time_azi_pos= numpy.zeros([k])
             # Contadores temporales
             p=0
             r=0
             z=0
             # VARIABLES TMP para almacenar azimuth, elevacion y tiempo
             #for filename in sorted(os.listdir(path_ped)):
             # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
             for filename in LIST:
                 tmp_azi_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos")
                 tmp_ele_pos   = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_pos")
                 # CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
                 if z==(m-1):
                     tmp_azi_time=numpy.arange(time_[z],time_[z]+1,1/(tmp_azi_pos.shape[0]))
                 else:
                     tmp_azi_time=numpy.arange(time_[z],time_[z+1],(time_[z+1]-time_[z])/(tmp_azi_pos.shape[0]))
                 print(filename,time_[z])
                 print(z,tmp_azi_pos.shape[0])
                 i=0
                 for i in range(tmp_azi_pos.shape[0]):
                     index=p+i
                     azi_pos[index]=tmp_azi_pos[i]
                     time_azi_pos[index]=tmp_azi_time[i]
                 p=p+tmp_azi_pos.shape[0]
                 i=0
                 for i in range(tmp_ele_pos.shape[0]):
                     index=r+i
                     ele_pos[index]=tmp_ele_pos[i]
                 r=r+tmp_ele_pos.shape[0]
                 z+=1
             ######## GRAFIQUEMOS Y VEAMOS LOS DATOS DEL Pedestal
             fig, ax = plt.subplots(figsize=(16,8))
             print(time_azi_pos.shape)
             print(azi_pos.shape)
             t=numpy.arange(time_azi_pos.shape[0])*0.01/(60.0)
             plt.plot(t,azi_pos,label='AZIMUTH_POS',color='blue')
             # AQUI ESTOY ADICIONANDO LA POSICION EN elevaciont=numpy.arange(len(ele_pos))*0.01/60.0
             t=numpy.arange(len(ele_pos))*0.01/60.0
             plt.plot(t,ele_pos,label='ELEVATION_POS',color='red')#*10
             #ax.set_xlim(0, 9)
-            ax.set_ylim(-5, 400)
+            ax.set_ylim(-5, 20)
             plt.ylabel("Azimuth Position")
             plt.xlabel("Muestra")
             plt.title('Azimuth Position vs Muestra ', fontsize=20)
             axes = plt.gca()
             axes.yaxis.grid()
             plt.xticks(fontsize=16)
             plt.yticks(fontsize=16)
             plt.show()

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