schain Commit - r1388:ec0a56a3ee09 · Jicamarca Repository

LAST UPDATE INTEGRACION

avaldez -

r1388:ec0a56a3ee09

parent child

Context file:

r1388:ec0a56a3ee09

Collapse all files

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

schainpy/scripts/basic_proc00001.py created 644 +213 0

@@ -0,0 +1,213
	1	# Ing. AVP
	2	# 06/10/2021
	3	# ARCHIVO DE LECTURA
	4	import os, sys
	5	import datetime
	6	import time
	7	from schainpy.controller import Project
	8	#### NOTA###########################################
	9	# INPUT :
	10	# VELOCIDAD PARAMETRO : V = 2°/seg
	11	# MODO PULSE PAIR O MOMENTOS: 0 : Pulse Pair ,1 : Momentos
	12	######################################################
	13	##### PROCESAMIENTO ##################################
	14	##### OJO TENER EN CUENTA EL n= para el Pulse Pair ##
	15	##### O EL n= nFFTPoints ###
	16	######################################################
	17	######## BUSCAMOS EL numero de IPP equivalente 1°#####
	18	######## Sea V la velocidad del Pedestal en °/seg#####
	19	######## 1° sera Recorrido en un tiempo de 1/V ######
	20	######## IPP del Radar 400 useg --> 60 Km ############
	21	######## n = 1/(V(°/seg)*IPP(Km)) , NUMERO DE IPP ##
	22	######## n = 1/(V*IPP) #############################
	23	######## VELOCIDAD DEL PEDESTAL ######################
	24	print("SETUP- RADAR METEOROLOGICO")
	25	V = 10
	26	mode = 1
	27	#path = '/DATA_RM/23/6v'
	28	path = '/DATA_RM/TEST_INTEGRACION_2M'
	29	path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
	30	figpath_pp = "/home/soporte/Pictures/TEST_PP"
	31	figpath_mom = "/home/soporte/Pictures/TEST_MOM"
	32	plot = 0
	33	integration = 1
	34	save = 0
	35	if save == 1:
	36	if mode==0:
	37	path_save = '/DATA_RM/TEST_HDF5_PP_23/6v'
	38	path_save = '/DATA_RM/TEST_HDF5_PP'
	39	path_save = '/DATA_RM/TEST_HDF5_PP_100'
	40	else:
	41	path_save = '/DATA_RM/TEST_HDF5_SPEC_23_V2/6v'
	42
	43	print("* PATH data ADQ :", path)
	44	print("* Velocidad Pedestal :",V,"°/seg")
	45	############################ NRO Perfiles PROCESAMIENTO ###################
	46	V=V
	47	IPP=400*1e-6
	48	n= int(1/(V*IPP))
	49	print("* n - NRO Perfiles Proc:", n )
	50	################################## MODE ###################################
	51	print("* Modo de Operacion :",mode)
	52	if mode ==0:
	53	print("* Met. Seleccionado : Pulse Pair")
	54	else:
	55	print("* Met. Momentos : Momentos")
	56
	57	################################## MODE ###################################
	58	print("* Grabado de datos :",save)
	59	if save ==1:
	60	if mode==0:
	61	ope= "Pulse Pair"
	62	else:
	63	ope= "Momentos"
	64	print("* Path-Save Data -", ope , path_save)
	65
	66	print("* Integracion de datos :",integration)
	67
	68	time.sleep(15)
	69	#remotefolder = "/home/wmaster/graficos"
	70	#######################################################################
	71	################# RANGO DE PLOTEO######################################
	72	dBmin = '1'
	73	dBmax = '85'
	74	xmin = '15'
	75	xmax = '15.25'
	76	ymin = '0'
	77	ymax = '600'
	78	#######################################################################
	79	########################FECHA##########################################
	80	str = datetime.date.today()
	81	today = str.strftime("%Y/%m/%d")
	82	str2 = str - datetime.timedelta(days=1)
	83	yesterday = str2.strftime("%Y/%m/%d")
	84	#######################################################################
	85	########################SIGNAL CHAIN ##################################
	86	#######################################################################
	87	desc = "USRP_test"
	88	filename = "USRP_processing.xml"
	89	controllerObj = Project()
	90	controllerObj.setup(id = '191', name='Test_USRP', description=desc)
	91	#######################################################################
	92	######################## UNIDAD DE LECTURA#############################
	93	#######################################################################
	94	readUnitConfObj = controllerObj.addReadUnit(datatype='DigitalRFReader',
	95	path=path,
	96	startDate="2021/01/01",#today,
	97	endDate="2021/12/30",#today,
	98	startTime='00:00:00',
	99	endTime='23:59:59',
	100	delay=0,
	101	#set=0,
	102	online=0,
	103	walk=1,
	104	ippKm = 60)
	105
	106	opObj11 = readUnitConfObj.addOperation(name='printInfo')
	107
	108	procUnitConfObjA = controllerObj.addProcUnit(datatype='VoltageProc', inputId=readUnitConfObj.getId())
	109
	110	if mode ==0:
	111	####################### METODO PULSE PAIR ######################################################################
	112	opObj11 = procUnitConfObjA.addOperation(name='PulsePair', optype='other')
	113	opObj11.addParameter(name='n', value=int(n), format='int')#10 VOY A USAR 250 DADO QUE LA VELOCIDAD ES 10 GRADOS
	114	#opObj11.addParameter(name='removeDC', value=1, format='int')
	115	####################### METODO Parametros ######################################################################
	116	procUnitConfObjB= controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjA.getId())
	117	if plot==1:
	118	opObj11 = procUnitConfObjB.addOperation(name='GenericRTIPlot',optype='external')
	119	opObj11.addParameter(name='attr_data', value='dataPP_POW')
	120	opObj11.addParameter(name='colormap', value='jet')
	121	opObj11.addParameter(name='xmin', value=xmin)
	122	opObj11.addParameter(name='xmax', value=xmax)
	123	opObj11.addParameter(name='zmin', value=dBmin)
	124	opObj11.addParameter(name='zmax', value=dBmax)
	125	opObj11.addParameter(name='save', value=figpath_pp)
	126	opObj11.addParameter(name='showprofile', value=0)
	127	opObj11.addParameter(name='save_period', value=50)
	128
	129	####################### METODO ESCRITURA #######################################################################
	130	if save==1:
	131	opObj10 = procUnitConfObjB.addOperation(name='HDFWriter')
	132	opObj10.addParameter(name='path',value=path_save)
	133	#opObj10.addParameter(name='mode',value=0)
	134	opObj10.addParameter(name='blocksPerFile',value='100',format='int')
	135	opObj10.addParameter(name='metadataList',value='utctimeInit,timeZone,paramInterval,profileIndex,channelList,heightList,flagDataAsBlock',format='list')
	136	opObj10.addParameter(name='dataList',value='dataPP_POW,dataPP_DOP,utctime',format='list')#,format='list'
	137	if integration==1:
	138	V=10
	139	blocksPerfile=360
	140	print("* Velocidad del Pedestal:",V)
	141	tmp_blocksPerfile = 100
	142	f_a_p= int(tmp_blocksPerfile/V)
	143
	144	opObj11 = procUnitConfObjB.addOperation(name='PedestalInformation')
	145	opObj11.addParameter(name='path_ped', value=path_ped)
	146	#opObj11.addParameter(name='path_adq', value=path_adq)
	147	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	148	opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
	149	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	150	opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
	151	opObj11.addParameter(name='online', value='0', format='int')
	152
	153	opObj11 = procUnitConfObjB.addOperation(name='Block360')
	154	opObj11.addParameter(name='n', value='10', format='int')
	155	opObj11.addParameter(name='mode', value=mode, format='int')
	156
	157	# este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
	158
	159	opObj11= procUnitConfObjB.addOperation(name='WeatherPlot',optype='other')
	160
	161
	162	else:
	163	####################### METODO SPECTROS ######################################################################
	164	procUnitConfObjB = controllerObj.addProcUnit(datatype='SpectraProc', inputId=procUnitConfObjA.getId())
	165	procUnitConfObjB.addParameter(name='nFFTPoints', value=n, format='int')
	166	procUnitConfObjB.addParameter(name='nProfiles' , value=n, format='int')
	167
	168	procUnitConfObjC = controllerObj.addProcUnit(datatype='ParametersProc',inputId=procUnitConfObjB.getId())
	169	procUnitConfObjC.addOperation(name='SpectralMoments')
	170	if plot==1:
	171	dBmin = '1'
	172	dBmax = '65'
	173	opObj11 = procUnitConfObjC.addOperation(name='PowerPlot',optype='external')
	174	opObj11.addParameter(name='xmin', value=xmin)
	175	opObj11.addParameter(name='xmax', value=xmax)
	176	opObj11.addParameter(name='zmin', value=dBmin)
	177	opObj11.addParameter(name='zmax', value=dBmax)
	178	opObj11.addParameter(name='save', value=figpath_mom)
	179	opObj11.addParameter(name='showprofile', value=0)
	180	opObj11.addParameter(name='save_period', value=100)
	181
	182	if save==1:
	183	opObj10 = procUnitConfObjC.addOperation(name='HDFWriter')
	184	opObj10.addParameter(name='path',value=path_save)
	185	#opObj10.addParameter(name='mode',value=0)
	186	opObj10.addParameter(name='blocksPerFile',value='360',format='int')
	187	#opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
	188	opObj10.addParameter(name='metadataList',value='utctimeInit,heightList,nIncohInt,nCohInt,nProfiles,channelList',format='list')#profileIndex
	189	opObj10.addParameter(name='dataList',value='data_pow,data_dop,utctime',format='list')#,format='list'
	190
	191	if integration==1:
	192	V=10
	193	blocksPerfile=360
	194	print("* Velocidad del Pedestal:",V)
	195	tmp_blocksPerfile = 100
	196	f_a_p= int(tmp_blocksPerfile/V)
	197
	198	opObj11 = procUnitConfObjC.addOperation(name='PedestalInformation')
	199	opObj11.addParameter(name='path_ped', value=path_ped)
	200	#opObj11.addParameter(name='path_adq', value=path_adq)
	201	opObj11.addParameter(name='t_Interval_p', value='0.01', format='float')
	202	opObj11.addParameter(name='blocksPerfile', value=blocksPerfile, format='int')
	203	opObj11.addParameter(name='n_Muestras_p', value='100', format='float')
	204	opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
	205	opObj11.addParameter(name='online', value='0', format='int')
	206
	207	opObj11 = procUnitConfObjC.addOperation(name='Block360')
	208	opObj11.addParameter(name='n', value='10', format='int')
	209	opObj11.addParameter(name='mode', value=mode, format='int')
	210
	211	# este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
	212	opObj11= procUnitConfObjC.addOperation(name='WeatherPlot',optype='other')
	213	controllerObj.start()

schainpy/scripts/check_pedestal.py created 644 +112 0

@@ -0,0 +1,112
	1	# Ing-AlexanderValdez
	2	# Monitoreo de Pedestal
	3
	4	############## IMPORTA LIBRERIAS ###################
	5	import os,numpy,h5py
	6	import sys,time
	7	import matplotlib.pyplot as plt
	8	####################################################
	9	path_ped = '/DATA_RM/TEST_PEDESTAL/P20211012-082745'
	10	# Metodo para verificar numero
	11	def isNumber(str):
	12	try:
	13	float(str)
	14	return True
	15	except:
	16	return False
	17	# Metodo para extraer el arreglo
	18	def getDatavaluefromDirFilename(path,file,value):
	19	dir_file= path+"/"+file
	20	fp = h5py.File(dir_file,'r')
	21	array = fp['Data'].get(value)[()]
	22	fp.close()
	23	return array
	24
	25	# LISTA COMPLETA DE ARCHIVOS HDF5 Pedestal
	26	LIST= sorted(os.listdir(path_ped))
	27	m=len(LIST)
	28	print("TOTAL DE ARCHIVOS DE PEDESTAL:",m)
	29	# Contadores temporales
	30	k= 0
	31	l= 0
	32	t= 0
	33	# Marca de tiempo temporal
	34	time_ = numpy.zeros([m])
	35	# creacion de
	36	for i in range(m):
	37	tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_pos")
	38	tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="ele_pos")
	39	tmp_azi_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel")
	40	tmp_ele_vel = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="azi_vel")# nuevo :D
	41
	42	time_[i] = getDatavaluefromDirFilename(path=path_ped,file=LIST[i],value="utc")
	43
	44	k=k +tmp_azi_pos.shape[0]
	45	l=l +tmp_ele_pos.shape[0]
	46	t=t +tmp_azi_vel.shape[0]
	47
	48	print("TOTAL DE MUESTRAS, ARCHIVOS X100:",k)
	49	time.sleep(5)
	50	######CREACION DE ARREGLOS CANTIDAD DE VALORES POR MUESTRA#################
	51	azi_pos = numpy.zeros([k])
	52	ele_pos = numpy.zeros([l])
	53	time_azi_pos= numpy.zeros([k])
	54	# Contadores temporales
	55	p=0
	56	r=0
	57	z=0
	58	# VARIABLES TMP para almacenar azimuth, elevacion y tiempo
	59
	60	#for filename in sorted(os.listdir(path_ped)):
	61	# CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
	62
	63	for filename in LIST:
	64	tmp_azi_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="azi_pos")
	65	tmp_ele_pos = getDatavaluefromDirFilename(path=path_ped,file=filename,value="ele_pos")
	66	# CONDICION POR LEER EN TIEMPO REAL NO OFFLINE
	67
	68	if z==(m-1):
	69	tmp_azi_time=numpy.arange(time_[z],time_[z]+1,1/(tmp_azi_pos.shape[0]))
	70	else:
	71	tmp_azi_time=numpy.arange(time_[z],time_[z+1],(time_[z+1]-time_[z])/(tmp_azi_pos.shape[0]))
	72
	73	print(filename,time_[z])
	74	print(z,tmp_azi_pos.shape[0])
	75
	76	i=0
	77	for i in range(tmp_azi_pos.shape[0]):
	78	index=p+i
	79	azi_pos[index]=tmp_azi_pos[i]
	80	time_azi_pos[index]=tmp_azi_time[i]
	81	p=p+tmp_azi_pos.shape[0]
	82	i=0
	83	for i in range(tmp_ele_pos.shape[0]):
	84	index=r+i
	85	ele_pos[index]=tmp_ele_pos[i]
	86	r=r+tmp_ele_pos.shape[0]
	87
	88
	89	z+=1
	90
	91
	92	######## GRAFIQUEMOS Y VEAMOS LOS DATOS DEL Pedestal
	93	fig, ax = plt.subplots(figsize=(16,8))
	94	print(time_azi_pos.shape)
	95	print(azi_pos.shape)
	96	t=numpy.arange(time_azi_pos.shape[0])*0.01/(60.0)
	97	plt.plot(t,azi_pos,label='AZIMUTH_POS',color='blue')
	98
	99	# AQUI ESTOY ADICIONANDO LA POSICION EN elevaciont=numpy.arange(len(ele_pos))*0.01/60.0
	100	t=numpy.arange(len(ele_pos))*0.01/60.0
	101	plt.plot(t,ele_pos,label='ELEVATION_POS',color='red')#*10
	102
	103	#ax.set_xlim(0, 9)
	104	ax.set_ylim(-5, 400)
	105	plt.ylabel("Azimuth Position")
	106	plt.xlabel("Muestra")
	107	plt.title('Azimuth Position vs Muestra ', fontsize=20)
	108	axes = plt.gca()
	109	axes.yaxis.grid()
	110	plt.xticks(fontsize=16)
	111	plt.yticks(fontsize=16)
	112	plt.show()

schainpy/scripts/test_fabiano.py created 644 +90 0

@@ -0,0 +1,90
	1	import os,sys,json
	2	import datetime
	3	import time
	4	from schainpy.controller import Project
	5	'''
	6	NOTA:
	7	Este script de prueba.
	8	- Unidad del lectura 'HDFReader'.
	9	- Unidad de procesamiento ParametersProc
	10	- Operacion SpectralMomentsPlot
	11
	12	'''
	13
	14	#######################################################################
	15	################# RANGO DE PLOTEO######################################
	16	#######################################################################
	17	dBmin = '1'
	18	dBmax = '65'
	19	xmin = '0'
	20	xmax ='24'
	21	#tmmin = 16.2
	22	#tmmax = 16.25
	23	tmmin =15
	24	tmmax =15.5
	25	ymin = '0'
	26	ymax = '600'
	27	#######################################################################
	28	#######################################################################
	29	#######################################################################
	30	#path = '/DATA_RM/TEST_HDF5_SPEC'
	31	path = '/DATA_RM/TEST_HDF5_SPEC_23/6v/'
	32	figpath = '/home/soporte/Downloads/23/6v'
	33	path="/home/soporte/Downloads/params-20211015T174046Z-001/params"
	34	desc = "Simulator Test"
	35	desc_data = {
	36	'Data': {
	37	'data_spc': ['Data/data_spc/channel00','Data/data_spc/channel01'\
	38	,'Data/data_spc/channel02','Data/data_spc/channel03'\
	39	,'Data/data_spc/channel04','Data/data_spc/channel05'\
	40	,'Data/data_spc/channel06','Data/data_spc/channel07'\
	41	,'Data/data_spc/channel08','Data/data_spc/channel09'],
	42	'utctime':'Data/utctime'
	43	},
	44	'Metadata': {
	45	'type' :'Metadata/type',
	46	'channelList' :'Metadata/channelList',
	47	'heightList' :'Metadata/heightList',
	48	'ippSeconds' :'Metadata/ippSeconds',
	49	'nProfiles' :'Metadata/nProfiles',
	50	'codeList' :'Metadata/codeList',
	51	'timeZone' :'Metadata/timeZone',
	52	'azimuthList' :'Metadata/azimuthList',
	53	'elevationList' :'Metadata/elevationList',
	54	'nCohInt' :'Metadata/nCohInt',
	55	'nIncohInt' :'Metadata/nIncohInt',
	56	'nFFTPoints' :'Metadata/nFFTPoints'
	57
	58	}
	59	}
	60
	61	controllerObj = Project()
	62
	63	controllerObj.setup(id='10',name='Test Simulator',description=desc)
	64
	65	readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
	66	path=path,
	67	startDate="2021/01/01", #"2020/01/01",#today,
	68	endDate= "2021/12/01", #"2020/12/30",#today,
	69	startTime='00:00:00',
	70	endTime='23:59:59',
	71	delay=0,
	72	#set=0,
	73	online=0,
	74	walk=0,
	75	description= json.dumps(desc_data))#1
	76
	77	procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
	78	procUnitConfObjA.addOperation(name='SpectralMoments')
	79
	80	'''
	81	opObj11 = readUnitConfObj.addOperation(name='SpectraPlot',optype='external')
	82	opObj11.addParameter(name='xmin', value=tmmin)
	83	opObj11.addParameter(name='xmax', value=tmmax)
	84	opObj11.addParameter(name='zmin', value=dBmin)
	85	opObj11.addParameter(name='zmax', value=dBmax)
	86	opObj11.addParameter(name='save', value=figpath)
	87	opObj11.addParameter(name='showprofile', value=0)
	88	opObj11.addParameter(name='save_period', value=10)
	89	'''
	90	controllerObj.start()

schainpy/model/graphics/jroplot_parameters.py +4 -3

             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
                 def update(self, dataOut):
                     data = {}
                     meta = {}
-                    data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(250**2))
+                    print("aprox",dataOut.data_360[0])
-                    print(data['weather'])
+                    data['weather'] = 10*numpy.log10(dataOut.data_360[0]/(250.0))
+                    #print(data['weather'])
                     data['azi']     = dataOut.data_azi
                     print("UPDATE",data['azi'])
                     return data, meta
                 def const_ploteo(self,data_weather,data_azi,step,res):
                     #print("data_weather",data_weather)
                     print("data_azi",data_azi)
                     print("step",step)
                     if self.ini==0:
                         #------- AZIMUTH
                         n     = (360/res)-len(data_azi)
                         start = data_azi[-1] + res
                         end   = data_azi[0]  - res
                         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))
                         # RADAR
                         val_mean         = numpy.mean(data_weather[:,0])
                         data_weather_cmp = numpy.ones([(360-data_weather.shape[0]),data_weather.shape[1]])*val_mean
                         data_weather     = numpy.vstack((data_weather,data_weather_cmp))
                     else:
                         # azimuth
                         flag=0
                         start_azi = self.res_azi[0]
                         start = data_azi[0]
                         end   = data_azi[-1]
                         print("start",start)
                         print("end",end)
                         if start< start_azi:
                             start = start +360
                         if end <start_azi:
                             end  = end +360
                         print("start",start)
                         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("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,"-----------------------------------")
                     #numpy.set_printoptions(suppress=True)
                     #print(self.data.times)
                     thisDatetime = datetime.datetime.utcfromtimestamp(self.data.times[-1])
                     data         = self.data[-1]
                     # ALTURA altura_tmp_h
                     altura_h     = (data['weather'].shape[1])/10.0
                     stoprange = float(altura_h*1.5)#stoprange = float(33*1.5) por ahora 400
                     rangestep = float(0.15)
                     r      = numpy.arange(0, stoprange, rangestep)
                     self.y = 2*r
                     # 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("alturas", len(self.y))
                     self.res_weather, self.res_azi = self.const_ploteo(data_weather=data['weather'],data_azi=data['azi'],step=step,res=res)
                     #numpy.set_printoptions(suppress=True)
                     #print("resultado",self.res_azi)
                     ##########################################################
                     #################    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)
                         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=0, vmax=60)
                     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')
                     self.ini= self.ini+1

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/scripts/WR_PROC_PP_PLOT_OFFLINE.py +12 -6

             import os,sys
             import datetime
             import time
             from schainpy.controller import Project
             #path='/DATA_RM/TEST_HDF5/d2021200'
             #path='/DATA_RM/TEST_HDF5/d2021200'
             #path='/DATA_RM/TEST_HDF5/d2021214'
             #path='/DATA_RM/TEST_HDF5/d2021229'
             #path='/DATA_RM/TEST_HDF5/d2021231'
             #path='/DATA_RM/TEST_HDF5/ADQ_OFFLINE/d2021231'
             path='/DATA_RM/TEST_HDF5/d2021231'
             #path='/DATA_RM/TEST_14_HDF5/d2021257'
             ## TEST ULTIMA PRUEBA 22 DE SEPTIEMBRE
             path = '/DATA_RM/TEST_HDF5_PP_22/d2021265'
+            #path = '/DATA_RM/TEST_HDF5_PP_100/d2021285'
+            path = '/DATA_RM/TEST_HDF5_PP/d2021285'
             path_adq=path
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021200'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021214'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P2021230'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20210819'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20210819-154315'
             #path_ped='/DATA_RM/TEST_PEDESTAL/P20210914-162434'
             #path_ped='/DATA_RM/TEST_PEDESTAL/PEDESTAL_OFFLINE/P20210819-161524'
             #pruebas con perdida de datos
             #path_ped='/DATA_RM/TEST_PEDESTAL/PEDESTAL_OFFLINE/P20210819-161524_TEST'
             ## TEST ULTIMA PRUEBA 22 DE SEPTIEMBRE
-            path_ped='/DATA_RM/TEST_PEDESTAL/P20210922-122731'
+            path_ped='/DATA_RM/TEST_PEDESTAL/P20211012-082745'
             figpath = '/home/soporte/Pictures'
             desc            = "Simulator Test"
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
                                                         path=path,
                                                         startDate="2021/01/01",   #"2020/01/01",#today,
                                                         endDate= "2021/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         t_Interval_p=0.01,
                                                         n_Muestras_p=100,
                                                         delay=30,
                                                         #set=0,
                                                         online=0,
                                                         walk=0,
                                                         nTries=6)#1
             procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
-            V=2
+            V=10
-            blocksPerfile=100
+            blocksPerfile=360
             print("Velocidad del Pedestal",V)
-            f_a_p= int(blocksPerfile/V)
+            tmp_blocksPerfile=100
+            f_a_p= int(tmp_blocksPerfile/V)
             opObj11 = procUnitConfObjA.addOperation(name='PedestalInformation')
             opObj11.addParameter(name='path_ped', value=path_ped)
-            opObj11.addParameter(name='path_adq', value=path_adq)
+            #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='blocksPerfile', value='100', format='int')
             opObj11.addParameter(name='f_a_p', value=f_a_p, format='int')
             opObj11.addParameter(name='online', value='0', format='int')# habilitar el enable aqui tambien
             opObj11 = procUnitConfObjA.addOperation(name='Block360')
             opObj11.addParameter(name='n', value='10', format='int')
+            opObj11.addParameter(name='mode', value=0, format='int')
             # este bloque funciona bien con divisores de 360 no olvidar 0 10 20 30 40 60 90 120 180
             opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
             #opObj11.addParameter(name='save', value=figpath)
             #opObj11.addParameter(name='save_period', value=1)
             controllerObj.start()
             #online 1 utc_adq 1617490240.48
             #online 0 utc_adq 1617489815.4804

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