schain Commit - r1778:799ea06d41f3 · Jicamarca Repository

UPDATE de operaciones en el Dominio de la Frecuencia y 2 scripts de prueba

sebastianVP -

r1778:799ea06d41f3

parent child

Context file:

r1778:799ea06d41f3

Collapse all files

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

schainpy/scripts/prueba1.py created 644 +386 0

@@ -0,0 +1,386
	1	#!python
	2	'''
	3	'''
	4
	5	import os, sys, json, argparse
	6	import datetime
	7	import time
	8
	9	from schainpy.controller import Project
	10
	11	PATH = "/home/pc-igp-179/Documentos/SOPHy"
	12
	13
	14	PARAM = {
	15	'S': {'zmin': -80, 'zmax':-45, 'colormap': 'jet' , 'label': 'Power', 'wrname': 'power','cb_label': 'dBm', 'ch':0},
	16	'SNR':{'zmin': -10, 'zmax': 15, 'colormap': 'jet' , 'label': 'SNR', 'wrname': 'snr','cb_label': 'dB', 'ch':0},
	17	'V': {'zmin': -12, 'zmax': 12, 'colormap': 'sophy_v', 'label': 'Velocity', 'wrname': 'velocity', 'cb_label': 'm/s', 'ch':0},
	18	'R': {'zmin': 0.5, 'zmax': 1 , 'colormap': 'sophy_r', 'label': 'RhoHV', 'wrname':'rhoHV', 'cb_label': '', 'ch':0},
	19	'P': {'zmin': -180,'zmax': 180,'colormap': 'sophy_p', 'label': 'PhiDP', 'wrname':'phiDP' , 'cb_label': 'degrees', 'ch':0},
	20	'D': {'zmin': -9 , 'zmax': 12, 'colormap': 'sophy_d', 'label': 'ZDR','wrname':'differential_reflectivity' , 'cb_label': 'dB','ch':0},
	21	'Z': {'zmin': -20, 'zmax': 80, 'colormap': 'sophy_z', 'label': 'Reflectivity ', 'wrname':'reflectivity', 'cb_label': 'dBz','ch':0},
	22	'W': {'zmin': 0 , 'zmax': 12, 'colormap': 'sophy_w', 'label': 'Spectral Width', 'wrname':'spectral_width', 'cb_label': 'm/s', 'ch':0}
	23	}
	24
	25	META = ['heightList', 'data_azi', 'data_ele', 'mode_op', 'latitude', 'longitude', 'altitude', 'heading', 'radar_name',
	26	'institution', 'contact', 'h0', 'range_unit', 'prf', 'prf_unit', 'variable', 'variable_unit', 'n_pulses',
	27	'pulse1_range', 'pulse1_width', 'pulse2_width', 'pulse1_repetitions', 'pulse2_repetitions', 'pulse_width_unit',
	28	'snr_threshold', 'data_noise']
	29
	30
	31	def max_index(r, sample_rate, ipp, h0,ipp_km):
	32
	33	return int(sample_rateipp1e6 * r / ipp_km) + int(sample_rateipp1e6 * -h0 / ipp_km)
	34
	35
	36	def main(args):
	37	experiment = args.experiment
	38
	39	fp = open(os.path.join(PATH, experiment, 'experiment.json'))
	40	conf = json.loads(fp.read())
	41
	42	ipp_km = conf['usrp_tx']['ipp']
	43	bottom = conf['pedestal']['bottom']
	44	ipp = ipp_km * 2 /300000
	45	sample_rate = conf['usrp_rx']['sample_rate']
	46	speed_axis = conf['pedestal']['speed']
	47
	48	if args.angles:
	49	angles = args.angles
	50	else:
	51	angles = conf['pedestal']['table']
	52
	53
	54
	55	start_date = conf['name'].split('@')[1].split('T')[0].replace('-', '/')
	56	end_date = start_date
	57	if args.start_time:
	58	start_time = args.start_time
	59	else:
	60	start_time = conf['name'].split('@')[1].split('T')[1].replace('-', ':')
	61
	62	if args.end_time:
	63	end_time = args.end_time
	64	else:
	65	end_time = '23:59:59'
	66
	67
	68	if args.label:
	69	label = '-{}'.format(args.label)
	70	else:
	71	label = ''
	72
	73	path_plots = os.path.join(PATH, experiment, 'plots{}'.format(label))
	74	path_save = os.path.join(PATH, experiment, 'param{}'.format(label))
	75
	76
	77	time_offset = args.time_offset
	78	parameters = args.parameters
	79
	80	N = int(1.0/(abs(speed_axis[0])*ipp))
	81	RMIX = 6.0
	82	H0 = -1.33
	83	MASK = args.mask
	84
	85	path = os.path.join(PATH, experiment, 'rawdata')
	86	path_ped = os.path.join(PATH, experiment, 'position')
	87
	88	proyecto = Project()
	89	proyecto.setup(id = '2', name='Test_2025', description="PRUEBA")
	90
	91	lectura = proyecto.addReadUnit(datatype='DigitalRFReader',
	92	path=path,
	93	startDate= "2025/01/06",#today,
	94	endDate= "2025/01/06",#today,
	95	startTime= start_time,
	96	endTime= end_time,
	97	delay=30,
	98	#set=0,
	99	online=0,
	100	walk=1,
	101	ippKm = ipp_km,
	102	getByBlock = 1,
	103	nProfileBlocks = N
	104	)
	105
	106	n_pulses = 1
	107	pulse_1_width = conf['usrp_tx']['pulse_1']
	108	pulse_1_repetitions = conf['usrp_tx']['repetitions_1']
	109	pulse_2_width = conf['usrp_tx']['pulse_2']
	110	pulse_2_repetitions = conf['usrp_tx']['repetitions_2']
	111
	112	if '1' in args.pulses:
	113	voltage1 = proyecto.addProcUnit(
	114	datatype='VoltageProc',
	115	inputId=lectura.getId()
	116	)
	117
	118	op = voltage1.addOperation(
	119	name='ProfileSelector'
	120	)
	121	op.addParameter(
	122	name='profileRangeList',
	123	value='0,{}'.format(conf['usrp_tx']['repetitions_1']-1)
	124	)
	125
	126	if conf['usrp_tx']['code_type_1'] != 'None':
	127	codes = [ c.strip() for c in conf['usrp_tx']['code_1'].split(',')]
	128	code = []
	129	for c in codes:
	130	code.append([int(x) for x in c])
	131	op = voltage1.addOperation(name='Decoder', optype='other')
	132	op.addParameter(name='code', value=code)
	133	op.addParameter(name='nCode', value=len(code), format='int')
	134	op.addParameter(name='nBaud', value=len(code[0]), format='int')
	135	ncode = len(code)
	136	else:
	137	ncode = 1
	138	code = ['0']
	139
	140	op = voltage1.addOperation(name='CohInt', optype='other')
	141	op.addParameter(name='n', value=ncode, format='int')
	142
	143	op = voltage1.addOperation(name='setH0')
	144	op.addParameter(name='h0', value=H0, format='float')
	145
	146	if args.range > 0:
	147	op = voltage1.addOperation(name='selectHeights')
	148	op.addParameter(name='minIndex', value=max_index(0, sample_rate, ipp, H0,ipp_km), format='int')
	149	op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp, H0,ipp_km), format='int')
	150
	151
	152	op = voltage1.addOperation(name='PulsePair_vRF', optype='other')
	153	op.addParameter(name='n', value=int(conf['usrp_tx']['repetitions_1'])/ncode, format='int')
	154
	155	if args.rmDC:
	156	op.addParameter(name='removeDC', value=1, format='int')
	157
	158	proc1 = proyecto.addProcUnit(datatype='ParametersProc', inputId=voltage1.getId())
	159	proc1.addParameter(name='runNextUnit', value=True)
	160
	161	opObj10 = proc1.addOperation(name="WeatherRadar")
	162	opObj10.addParameter(name='CR_Flag',value=True)
	163	print(1, len(code[0]))
	164	opObj10.addParameter(name='tauW',value=(1e-6/sample_rate)*len(code[0]))
	165	opObj10.addParameter(name='Pt',value=200)
	166	opObj10.addParameter(name='min_index',value=max_index(0, sample_rate, ipp, H0,ipp_km))
	167
	168
	169	op = proc1.addOperation(name='PedestalInformation')
	170	op.addParameter(name='path', value=path_ped, format='str')
	171	op.addParameter(name='interval', value='0.04')
	172	op.addParameter(name='time_offset', value=time_offset)
	173	op.addParameter(name='mode', value=args.mode)
	174
	175	op = proc1.addOperation(name='Block360')
	176	op.addParameter(name='attr_data', value='data_param')
	177	op.addParameter(name='runNextOp', value=True)
	178	op.addParameter(name='angles', value=angles)
	179	op.addParameter(name='heading', value=conf['heading'])
	180
	181
	182	if '2' in args.pulses:
	183	voltage2 = proyecto.addProcUnit(
	184	datatype='VoltageProc',
	185	inputId=lectura.getId()
	186	)
	187
	188	op = voltage2.addOperation(
	189	name='ProfileSelector'
	190	)
	191	op.addParameter(
	192	name='profileRangeList',
	193	value='{},{}'.format(conf['usrp_tx']['repetitions_1'], conf['usrp_tx']['repetitions_1']+conf['usrp_tx']['repetitions_2']-1)
	194	)
	195
	196	if conf['usrp_tx']['code_type_2']:
	197	codes = [ c.strip() for c in conf['usrp_tx']['code_2'].split(',')]
	198	code = []
	199	for c in codes:
	200	code.append([int(x) for x in c])
	201	op = voltage2.addOperation(name='Decoder', optype='other')
	202	op.addParameter(name='code', value=code)
	203	op.addParameter(name='nCode', value=len(code), format='int')
	204	op.addParameter(name='nBaud', value=len(code[0]), format='int')
	205
	206	op = voltage2.addOperation(name='CohInt', optype='other')
	207	op.addParameter(name='n', value=len(code), format='int')
	208
	209	ncode = len(code)
	210	else:
	211	ncode = 1
	212
	213	op = voltage2.addOperation(name='setH0')
	214	op.addParameter(name='h0', value=H0, format='float')
	215
	216	if args.range > 0:
	217	op = voltage2.addOperation(name='selectHeights')
	218	op.addParameter(name='minIndex', value=max_index(0, sample_rate, ipp, H0,ipp_km), format='int')
	219	op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp, H0,ipp_km), format='int')
	220
	221
	222	op = voltage2.addOperation(name='PulsePair_vRF', optype='other')
	223	op.addParameter(name='n', value=int(conf['usrp_tx']['repetitions_1'])/ncode, format='int')
	224
	225	proc2 = proyecto.addProcUnit(datatype='ParametersProc', inputId=voltage2.getId())
	226	proc2.addParameter(name='runNextUnit', value=True)
	227
	228	opObj10 = proc2.addOperation(name="WeatherRadar")
	229	opObj10.addParameter(name='CR_Flag',value=True,format='bool')
	230	print(2, len(code[0]))
	231	opObj10.addParameter(name='tauW',value=(1e-6/sample_rate)*len(code[0]))
	232	opObj10.addParameter(name='Pt',value=200)
	233	opObj10.addParameter(name='min_index',value=max_index(RMIX, sample_rate, ipp, H0,ipp_km))
	234
	235	op = proc2.addOperation(name='PedestalInformation')
	236	op.addParameter(name='path', value=path_ped, format='str')
	237	op.addParameter(name='interval', value='0.04')
	238	op.addParameter(name='time_offset', value=time_offset)
	239	op.addParameter(name='mode', value=args.mode)
	240	op.addParameter(name='heading', value=conf['heading'])
	241
	242	op = proc2.addOperation(name='Block360')
	243	op.addParameter(name='attr_data', value='data_param')
	244	op.addParameter(name='runNextOp', value=True)
	245	op.addParameter(name='angles', value=angles)
	246	op.addParameter(name='heading', value=conf['heading'])
	247
	248	if '1' in args.pulses and '2' in args.pulses:
	249	merge = proyecto.addProcUnit(datatype='MergeProc', inputId=[proc1.getId(), proc2.getId()])
	250	merge.addParameter(name='attr_data', value='data_param')
	251	merge.addParameter(name='mode', value='7')
	252	merge.addParameter(name='index', value=max_index(RMIX, sample_rate, ipp, H0,ipp_km))
	253
	254	elif '1' in args.pulses:
	255	merge = proc1
	256	elif '2' in args.pulses:
	257	merge = proc2
	258
	259	for param in parameters:
	260
	261	if args.plot:
	262	op= merge.addOperation(name='WeatherParamsPlot')
	263	if args.save:
	264	op.addParameter(name='save', value=path_plots, format='str')
	265	op.addParameter(name='save_period', value=-1)
	266	op.addParameter(name='show', value=args.show)
	267	op.addParameter(name='channels', value='0,')
	268	op.addParameter(name='zmin', value=PARAM[param]['zmin'], format='int')
	269	op.addParameter(name='zmax', value=PARAM[param]['zmax'], format='int')
	270	op.addParameter(name='yrange', value=20, format='int')
	271	op.addParameter(name='xrange', value=args.range, format='int')
	272	op.addParameter(name='attr_data', value=param, format='str')
	273	op.addParameter(name='labels', value=[[PARAM[param]['label']], [PARAM[param]['label']]])
	274	op.addParameter(name='save_code', value=param)
	275	op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
	276	op.addParameter(name='colormap', value=PARAM[param]['colormap'])
	277	op.addParameter(name='bgcolor', value='black')
	278	op.addParameter(name='localtime', value=False)
	279	op.addParameter(name='shapes', value='./shapes')
	280	op.addParameter(name='latitude', value=conf['latitude'], format='float')
	281	op.addParameter(name='longitude', value=conf['longitude'], format='float')
	282	op.addParameter(name='map', value=True)
	283
	284	if MASK: op.addParameter(name='mask', value=MASK, format='float')
	285	if args.server:
	286	op.addParameter(name='server', value='190.187.237.239:4444')
	287	op.addParameter(name='exp_code', value='400')
	288
	289	desc = {
	290	'Data': {
	291	'data_param': {PARAM[param]['wrname']: ['H', 'V']},
	292	'utctime': 'time'
	293	},
	294	'Metadata': {
	295	'heightList': 'range',
	296	'data_azi': 'azimuth',
	297	'data_ele': 'elevation',
	298	'mode_op': 'scan_type',
	299	'h0': 'range_correction',
	300	'dataPP_NOISE': 'noise',
	301	}
	302	}
	303
	304	if args.save:
	305	writer = merge.addOperation(name='HDFWriter')
	306	writer.addParameter(name='path', value=path_save, format='str')
	307	writer.addParameter(name='Reset', value=True)
	308	writer.addParameter(name='setType', value='weather')
	309	writer.addParameter(name='setChannel', value='0') #new parameter choose ch 0 H or ch 1 V
	310	writer.addParameter(name='description', value=json.dumps(desc))
	311	writer.addParameter(name='blocksPerFile', value='1',format='int')
	312	writer.addParameter(name='metadataList', value=','.join(META))
	313	writer.addParameter(name='dataList', value='data_param,utctime')
	314	writer.addParameter(name='weather_var', value=param)
	315	writer.addParameter(name='mask', value=MASK, format='float')
	316	writer.addParameter(name='localtime', value=False)
	317	# meta
	318	writer.addParameter(name='latitude', value=conf['latitude'])
	319	writer.addParameter(name='longitude', value=conf['longitude'])
	320	writer.addParameter(name='altitude', value=conf['altitude'])
	321	writer.addParameter(name='heading', value=conf['heading'])
	322	writer.addParameter(name='radar_name', value='SOPHy')
	323	writer.addParameter(name='institution', value='IGP')
	324	writer.addParameter(name='contact', value='dscipion@igp.gob.pe')
	325	writer.addParameter(name='created_by', value='Signal Chain (https://pypi.org/project/schainpy/)')
	326	writer.addParameter(name='range_unit', value='km')
	327	writer.addParameter(name='prf', value=1/ipp)
	328	writer.addParameter(name='prf_unit', value='hertz')
	329	writer.addParameter(name='variable', value=PARAM[param]['label'])
	330	writer.addParameter(name='variable_unit', value=PARAM[param]['cb_label'])
	331	writer.addParameter(name='n_pulses', value=n_pulses)
	332	writer.addParameter(name='pulse1_range', value=RMIX)
	333	writer.addParameter(name='pulse1_width', value=pulse_1_width)
	334	writer.addParameter(name='pulse2_width', value=pulse_2_width)
	335	writer.addParameter(name='pulse1_repetitions', value=pulse_1_repetitions)
	336	writer.addParameter(name='pulse2_repetitions', value=pulse_2_repetitions)
	337	writer.addParameter(name='pulse_width_unit', value='microseconds')
	338	writer.addParameter(name='snr_threshold', value=MASK)
	339	writer.addParameter(name='cr_hv', value=[67.41,67.17]) #new parameter
	340
	341
	342	return proyecto
	343
	344
	345
	346
	347	if __name__ == '__main__':
	348
	349	parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
	350	parser.add_argument('experiment',
	351	help='Experiment name')
	352	parser.add_argument('--parameters', nargs='*', default=['S'],
	353	help='Variables to process: P, Z, V')
	354	parser.add_argument('--pulses', nargs='*', default=['1', '2'],
	355	help='Variables to process: 1, 2')
	356	parser.add_argument('--range', default=60, type=float,
	357	help='Max range to plot')
	358	parser.add_argument('--server', action='store_true',
	359	help='Send to realtime')
	360	parser.add_argument('--start_time', default='',
	361	help='Set start time.')
	362	parser.add_argument('--end_time', default='',
	363	help='Set end time.')
	364	parser.add_argument('--rmDC', action='store_true',
	365	help='Apply remove DC.')
	366	parser.add_argument('--time_offset', default=0,
	367	help='Fix time offset')
	368	parser.add_argument('--mode', default=None,
	369	help='Type of scan')
	370	parser.add_argument('--angles', nargs='*', default=[], type=int,
	371	help='Angles to process')
	372	parser.add_argument('--plot', action='store_true',
	373	help='Create plot files')
	374	parser.add_argument('--save', action='store_true',
	375	help='Create output files')
	376	parser.add_argument('--show', action='store_true',
	377	help='Show matplotlib plot.')
	378	parser.add_argument('--mask', default=0.36, type=float,
	379	help='Filter mask over SNR')
	380	parser.add_argument('--label', default='',
	381	help='Label for plot & param folder')
	382
	383	args = parser.parse_args()
	384
	385	proyecto= main(args)
	386	proyecto.start() No newline at end of file

schainpy/scripts/prueba2.py created 644 +381 0

@@ -0,0 +1,381
	1	import os, sys, json, argparse
	2	import multiprocessing
	3	import datetime
	4	import time
	5
	6	PATH = "/home/pc-igp-179/Documentos/SOPHy"
	7
	8	PARAM = {
	9	'S': {'zmin': -80, 'zmax':-45, 'colormap': 'jet' , 'label': 'Power', 'wrname': 'power','cb_label': 'dBm', 'ch':0},
	10	'SNR':{'zmin': -10, 'zmax': 15, 'colormap': 'jet' , 'label': 'SNR', 'wrname': 'snr','cb_label': 'dB', 'ch':0},
	11	'V': {'zmin': -12, 'zmax': 12, 'colormap': 'sophy_v', 'label': 'Velocity', 'wrname': 'velocity', 'cb_label': 'm/s', 'ch':0},
	12	'R': {'zmin': 0.5, 'zmax': 1 , 'colormap': 'sophy_r', 'label': 'RhoHV', 'wrname':'rhoHV', 'cb_label': '', 'ch':0},
	13	'P': {'zmin': -180,'zmax': 180,'colormap': 'sophy_p', 'label': 'PhiDP', 'wrname':'phiDP' , 'cb_label': 'degrees', 'ch':0},
	14	'D': {'zmin': -9 , 'zmax': 12, 'colormap': 'sophy_d', 'label': 'ZDR','wrname':'differential_reflectivity' , 'cb_label': 'dB','ch':0},
	15	'Z': {'zmin': -20, 'zmax': 80, 'colormap': 'sophy_z', 'label': 'Reflectivity ', 'wrname':'reflectivity', 'cb_label': 'dBz','ch':0},
	16	'W': {'zmin': 0 , 'zmax': 12, 'colormap': 'sophy_w', 'label': 'Spectral Width', 'wrname':'spectral_width', 'cb_label': 'm/s', 'ch':0}
	17	}
	18
	19	META = ['heightList', 'data_azi', 'data_ele', 'mode_op', 'latitude', 'longitude', 'altitude', 'heading', 'radar_name',
	20	'institution', 'contact', 'h0', 'range_unit', 'prf', 'prf_unit', 'variable', 'variable_unit', 'n_pulses',
	21	'pulse1_range', 'pulse1_width', 'pulse2_width', 'pulse1_repetitions', 'pulse2_repetitions', 'pulse_width_unit',
	22	'snr_threshold', 'data_noise']
	23
	24
	25	def max_index(r, sample_rate, ipp, h0,ipp_km):
	26
	27	return int(sample_rateipp1e6 * r / ipp_km) + int(sample_rateipp1e6 * -h0 / ipp_km)
	28
	29	def main(args):
	30
	31	experiment = args.experiment
	32	fp = open(os.path.join(PATH, experiment, 'experiment.json'))
	33	conf = json.loads(fp.read())
	34
	35	ipp_km = conf['usrp_tx']['ipp']
	36	bottom = conf['pedestal']['bottom']
	37	ipp = ipp_km * 2 /300000
	38	sample_rate = conf['usrp_rx']['sample_rate']
	39	speed_axis = conf['pedestal']['speed']
	40	if args.angles:
	41	angles = args.angles
	42	else:
	43	angles = conf['pedestal']['table']
	44	time_offset = args.time_offset
	45	parameters = args.parameters
	46	start_date = conf['name'].split('@')[1].split('T')[0].replace('-', '/')
	47	end_date = start_date
	48	if args.start_time:
	49	start_time = args.start_time
	50	else:
	51	start_time = conf['name'].split('@')[1].split('T')[1].replace('-', ':')
	52
	53	if args.end_time:
	54	end_time = args.end_time
	55	else:
	56	end_time = '23:59:59'
	57
	58	N = int(1.0/(abs(speed_axis[0])*ipp))
	59
	60	path = os.path.join(PATH, experiment, 'rawdata')
	61
	62	path_ped = os.path.join(PATH, experiment, 'position')
	63	if args.label:
	64	label = '-{}'.format(args.label)
	65	else:
	66	label = ''
	67	path_plots = os.path.join(PATH, experiment, 'plots{}'.format(label))
	68	path_save = os.path.join(PATH, experiment, 'param{}'.format(label))
	69	RMIX = 6.0
	70	H0 = -1.33
	71	MASK = args.mask
	72
	73	from schainpy.controller import Project
	74
	75	project = Project()
	76	project.setup(id='1', name='Sophy', description='sophy proc')
	77
	78	reader = project.addReadUnit(datatype='DigitalRFReader',
	79	path=path,
	80	startDate=start_date,
	81	endDate=end_date,
	82	startTime=start_time,
	83	endTime=end_time,
	84	delay=0,
	85	online=args.online,
	86	walk=0,
	87	ippKm = ipp_km,
	88	getByBlock = 1,
	89	nProfileBlocks = N,
	90	)
	91
	92
	93	n_pulses = 1
	94	pulse_1_width = conf['usrp_tx']['pulse_1']
	95	pulse_1_repetitions = conf['usrp_tx']['repetitions_1']
	96	pulse_2_width = conf['usrp_tx']['pulse_2']
	97	pulse_2_repetitions = conf['usrp_tx']['repetitions_2']
	98
	99	if '1' in args.pulses:
	100	voltage1 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
	101
	102	op = voltage1.addOperation(name='ProfileSelector')
	103	op.addParameter(name='profileRangeList', value='0,{}'.format(conf['usrp_tx']['repetitions_1']-1))
	104
	105	if conf['usrp_tx']['code_type_1'] != 'None':
	106	codes = [ c.strip() for c in conf['usrp_tx']['code_1'].split(',')]
	107	code = []
	108	for c in codes:
	109	code.append([int(x) for x in c])
	110	op = voltage1.addOperation(name='Decoder', optype='other')
	111	op.addParameter(name='code', value=code)
	112	op.addParameter(name='nCode', value=len(code), format='int')
	113	op.addParameter(name='nBaud', value=len(code[0]), format='int')
	114	ncode = len(code)
	115	else:
	116	ncode = 1
	117	code = ['0']
	118
	119
	120	op = voltage1.addOperation(name='CohInt', optype='other')
	121	op.addParameter(name='n', value=ncode, format='int')
	122
	123	op = voltage1.addOperation(name='setH0')
	124	op.addParameter(name='h0', value=H0, format='float')
	125
	126	if args.range > 0:
	127	op = voltage1.addOperation(name='selectHeights')
	128	op.addParameter(name='minIndex', value=max_index(0, sample_rate, ipp, H0,ipp_km), format='int')
	129	op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp, H0,ipp_km), format='int')
	130
	131
	132
	133	#op = voltage1.addOperation(name='PulsePair_vRF', optype='other')
	134	#op.addParameter(name='n', value=int(conf['usrp_tx']['repetitions_1'])/ncode, format='int')
	135
	136	procUnitConfObjA = project.addProcUnit(datatype='SpectraProc', inputId=voltage1.getId())
	137	procUnitConfObjA.addParameter(name='nFFTPoints', value=int(conf['usrp_tx']['repetitions_1'])/ncode, format='int')
	138	procUnitConfObjA.addParameter(name='nProfiles', value=int(conf['usrp_tx']['repetitions_1'])/ncode, format='int')
	139
	140
	141	#opObj11 = procUnitConfObjA.addOperation(name='setRadarFrequency')
	142	#opObj11.addParameter(name='frequency', value='9.345e9', format='float')
	143	#procUnitConfObjA.addOperation(name='removeDC')
	144	#if args.rmDC:
	145	# op.addParameter(name='removeDC', value=1, format='int')
	146
	147	proc1 = project.addProcUnit(datatype='ParametersProc', inputId=procUnitConfObjA.getId())
	148	proc1.addOperation(name='SpectralMoments')
	149
	150	proc1.addParameter(name='runNextUnit', value=True)
	151
	152	opObj10 = proc1.addOperation(name="WeatherRadar")
	153	opObj10.addParameter(name='CR_Flag',value=True)
	154	#print(1, len(code[0]))
	155	opObj10.addParameter(name='tauW',value=(1e-6/sample_rate)*len(code[0]))
	156	opObj10.addParameter(name='Pt',value=200)
	157	opObj10.addParameter(name='min_index',value=max_index(0, sample_rate, ipp, H0,ipp_km))
	158
	159
	160	op = proc1.addOperation(name='PedestalInformation')
	161	op.addParameter(name='path', value=path_ped, format='str')
	162	op.addParameter(name='interval', value='0.04')
	163	op.addParameter(name='time_offset', value=time_offset)
	164	op.addParameter(name='mode', value=args.mode)
	165
	166	op = proc1.addOperation(name='Block360')
	167	op.addParameter(name='attr_data', value='data_param')
	168	op.addParameter(name='runNextOp', value=True)
	169	op.addParameter(name='angles', value=angles)
	170	op.addParameter(name='heading', value=conf['heading'])
	171
	172
	173	if '2' in args.pulses:
	174	voltage2 = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
	175
	176	op = voltage2.addOperation(name='ProfileSelector')
	177	op.addParameter(name='profileRangeList', value='{},{}'.format(conf['usrp_tx']['repetitions_1'], conf['usrp_tx']['repetitions_1']+conf['usrp_tx']['repetitions_2']-1))
	178
	179	if conf['usrp_tx']['code_type_2']:
	180	codes = [ c.strip() for c in conf['usrp_tx']['code_2'].split(',')]
	181	code = []
	182	for c in codes:
	183	code.append([int(x) for x in c])
	184	op = voltage2.addOperation(name='Decoder', optype='other')
	185	op.addParameter(name='code', value=code)
	186	op.addParameter(name='nCode', value=len(code), format='int')
	187	op.addParameter(name='nBaud', value=len(code[0]), format='int')
	188
	189	op = voltage2.addOperation(name='CohInt', optype='other')
	190	op.addParameter(name='n', value=len(code), format='int')
	191
	192	ncode = len(code)
	193	else:
	194	ncode = 1
	195
	196	op = voltage2.addOperation(name='setH0')
	197	op.addParameter(name='h0', value=H0, format='float')
	198
	199	if args.range > 0:
	200	op = voltage2.addOperation(name='selectHeights')
	201	op.addParameter(name='minIndex', value=max_index(0, sample_rate, ipp, H0,ipp_km), format='int')
	202	op.addParameter(name='maxIndex', value=max_index(args.range, sample_rate, ipp, H0,ipp_km), format='int')
	203
	204
	205
	206
	207	procUnitConfObjB = project.addProcUnit(datatype='SpectraProc', inputId=voltage2.getId())
	208	procUnitConfObjB.addParameter(name='nFFTPoints', value=int(conf['usrp_tx']['repetitions_2'])/ncode, format='int')
	209	procUnitConfObjB.addParameter(name='nProfiles', value=int(conf['usrp_tx']['repetitions_2'])/ncode, format='int')
	210
	211
	212
	213	#opObj11 = procUnitConfObjB.addOperation(name='setRadarFrequency')
	214	#opObj11.addParameter(name='frequency', value='9.345e9', format='float')
	215	#procUnitConfObjB.addOperation(name='removeDC')
	216
	217	#if args.rmDC:
	218	# op.addParameter(name='removeDC', value=1, format='int')
	219
	220	proc2 = project.addProcUnit(datatype='ParametersProc', inputId=procUnitConfObjB.getId())
	221	proc2.addOperation(name='SpectralMoments')
	222	proc2.addParameter(name='runNextUnit', value=True)
	223
	224	opObj10 = proc2.addOperation(name="WeatherRadar")
	225	opObj10.addParameter(name='CR_Flag',value=True,format='bool')
	226	opObj10.addParameter(name='tauW',value=(1e-6/sample_rate)*len(code[0]))
	227	opObj10.addParameter(name='Pt',value=200)
	228	opObj10.addParameter(name='min_index',value=max_index(RMIX, sample_rate, ipp, H0,ipp_km))
	229
	230	op = proc2.addOperation(name='PedestalInformation')
	231	op.addParameter(name='path', value=path_ped, format='str')
	232	op.addParameter(name='interval', value='0.04')
	233	op.addParameter(name='time_offset', value=time_offset)
	234	op.addParameter(name='mode', value=args.mode)
	235	op.addParameter(name='heading', value=conf['heading'])
	236
	237	op = proc2.addOperation(name='Block360')
	238	op.addParameter(name='attr_data', value='data_param')
	239	op.addParameter(name='runNextOp', value=True)
	240	op.addParameter(name='angles', value=angles)
	241	op.addParameter(name='heading', value=conf['heading'])
	242
	243
	244	if '1' in args.pulses and '2' in args.pulses:
	245	merge = project.addProcUnit(datatype='MergeProc', inputId=[proc1.getId(), proc2.getId()])
	246	merge.addParameter(name='attr_data', value='data_param')
	247	merge.addParameter(name='mode', value='7')
	248	merge.addParameter(name='index', value=max_index(RMIX, sample_rate, ipp, H0,ipp_km))
	249
	250	elif '1' in args.pulses:
	251	merge = proc1
	252	elif '2' in args.pulses:
	253	merge = proc2
	254
	255
	256	for param in parameters:
	257
	258	if args.plot:
	259	op= merge.addOperation(name='WeatherParamsPlot')
	260	if args.save:
	261	op.addParameter(name='save', value=path_plots, format='str')
	262	op.addParameter(name='save_period', value=-1)
	263	op.addParameter(name='show', value=args.show)
	264	op.addParameter(name='channels', value='0,')
	265	op.addParameter(name='zmin', value=PARAM[param]['zmin'], format='int')
	266	op.addParameter(name='zmax', value=PARAM[param]['zmax'], format='int')
	267	op.addParameter(name='yrange', value=20, format='int')
	268	op.addParameter(name='xrange', value=args.range, format='int')
	269	op.addParameter(name='attr_data', value=param, format='str')
	270	op.addParameter(name='labels', value=[[PARAM[param]['label']], [PARAM[param]['label']]])
	271	op.addParameter(name='save_code', value=param)
	272	op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
	273	op.addParameter(name='colormap', value=PARAM[param]['colormap'])
	274	op.addParameter(name='bgcolor', value='black')
	275	op.addParameter(name='localtime', value=False)
	276	op.addParameter(name='shapes', value='./shapes')
	277	op.addParameter(name='latitude', value=conf['latitude'], format='float')
	278	op.addParameter(name='longitude', value=conf['longitude'], format='float')
	279	op.addParameter(name='map', value=True)
	280
	281	if MASK: op.addParameter(name='mask', value=MASK, format='float')
	282	#if args.server:
	283	# op.addParameter(name='server', value='190.187.237.239:4444')
	284	# op.addParameter(name='exp_code', value='400')
	285
	286	desc = {
	287	'Data': {
	288	'data_param': {PARAM[param]['wrname']: ['H', 'V']},
	289	'utctime': 'time'
	290	},
	291	'Metadata': {
	292	'heightList': 'range',
	293	'data_azi': 'azimuth',
	294	'data_ele': 'elevation',
	295	'mode_op': 'scan_type',
	296	'h0': 'range_correction',
	297	'dataPP_NOISE': 'noise',
	298	}
	299	}
	300
	301	if args.save:
	302	writer = merge.addOperation(name='HDFWriter')
	303	writer.addParameter(name='path', value=path_save, format='str')
	304	writer.addParameter(name='Reset', value=True)
	305	writer.addParameter(name='setType', value='weather')
	306	writer.addParameter(name='setChannel', value='0') #new parameter choose ch 0 H or ch 1 V
	307	writer.addParameter(name='description', value=json.dumps(desc))
	308	writer.addParameter(name='blocksPerFile', value='1',format='int')
	309	writer.addParameter(name='metadataList', value=','.join(META))
	310	writer.addParameter(name='dataList', value='data_param,utctime')
	311	writer.addParameter(name='weather_var', value=param)
	312	writer.addParameter(name='mask', value=MASK, format='float')
	313	writer.addParameter(name='localtime', value=False)
	314	# meta
	315	writer.addParameter(name='latitude', value=conf['latitude'])
	316	writer.addParameter(name='longitude', value=conf['longitude'])
	317	writer.addParameter(name='altitude', value=conf['altitude'])
	318	writer.addParameter(name='heading', value=conf['heading'])
	319	writer.addParameter(name='radar_name', value='SOPHy')
	320	writer.addParameter(name='institution', value='IGP')
	321	writer.addParameter(name='contact', value='dscipion@igp.gob.pe')
	322	writer.addParameter(name='created_by', value='Signal Chain (https://pypi.org/project/schainpy/)')
	323	writer.addParameter(name='range_unit', value='km')
	324	writer.addParameter(name='prf', value=1/ipp)
	325	writer.addParameter(name='prf_unit', value='hertz')
	326	writer.addParameter(name='variable', value=PARAM[param]['label'])
	327	writer.addParameter(name='variable_unit', value=PARAM[param]['cb_label'])
	328	writer.addParameter(name='n_pulses', value=n_pulses)
	329	writer.addParameter(name='pulse1_range', value=RMIX)
	330	writer.addParameter(name='pulse1_width', value=pulse_1_width)
	331	writer.addParameter(name='pulse2_width', value=pulse_2_width)
	332	writer.addParameter(name='pulse1_repetitions', value=pulse_1_repetitions)
	333	writer.addParameter(name='pulse2_repetitions', value=pulse_2_repetitions)
	334	writer.addParameter(name='pulse_width_unit', value='microseconds')
	335	writer.addParameter(name='snr_threshold', value=MASK)
	336	writer.addParameter(name='cr_hv', value=[67.41,67.17]) #new parameter
	337
	338	return project
	339
	340	if __name__ == '__main__':
	341
	342	parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
	343	parser.add_argument('experiment',
	344	help='Experiment name')
	345	parser.add_argument('--parameters', nargs='*', default=['S'],
	346	help='Variables to process: P, Z, V')
	347	parser.add_argument('--pulses', nargs='*', default=['1', '2'],
	348	help='Variables to process: 1, 2')
	349	parser.add_argument('--angles', nargs='*', default=[], type=int,
	350	help='Angles to process')
	351	parser.add_argument('--time_offset', default=0,
	352	help='Fix time offset')
	353	parser.add_argument('--range', default=60, type=float,
	354	help='Max range to plot')
	355
	356	parser.add_argument('--save', action='store_true',
	357	help='Create output files')
	358	parser.add_argument('--plot', action='store_true',
	359	help='Create plot files')
	360	parser.add_argument('--show', action='store_true',
	361	help='Show matplotlib plot.')
	362	parser.add_argument('--online', action='store_true',
	363	help='Set online mode.')
	364	parser.add_argument('--server', action='store_true',
	365	help='Send to realtime')
	366	parser.add_argument('--start_time', default='',
	367	help='Set start time.')
	368	parser.add_argument('--end_time', default='',
	369	help='Set end time.')
	370	parser.add_argument('--label', default='',
	371	help='Label for plot & param folder')
	372	parser.add_argument('--mode', default=None,
	373	help='Type of scan')
	374	#parser.add_argument('--rmDC', action='store_true',
	375	# help='Apply remove DC.')
	376	parser.add_argument('--mask', default=0, type=float,
	377	help='Set SNR threshold.')
	378	args = parser.parse_args()
	379
	380	project = main(args)
	381	project.start() No newline at end of file

schainpy/model/graphics/jroplot_parameters.py +20 -5

             import os
             import datetime
             import warnings
             import numpy
             from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
             from matplotlib.patches import Circle
             from cartopy.feature import ShapelyFeature
             import cartopy.io.shapereader as shpreader
             from schainpy.model.graphics.jroplot_base import Plot, plt, ccrs
             from schainpy.model.graphics.jroplot_spectra import SpectraPlot, RTIPlot, CoherencePlot, SpectraCutPlot
             from schainpy.utils import log
             from schainpy.model.graphics.plotting_codes import cb_tables
             EARTH_RADIUS = 6.3710e3
             def antenna_to_cartesian(ranges, azimuths, elevations):
                 """
                 Return Cartesian coordinates from antenna coordinates.
                 Parameters
                 ----------
                 ranges : array
                     Distances to the center of the radar gates (bins) in kilometers.
                 azimuths : array
                     Azimuth angle of the radar in degrees.
                 elevations : array
                     Elevation angle of the radar in degrees.
                 Returns
                 -------
                 x, y, z : array
                     Cartesian coordinates in meters from the radar.
                 Notes
                 -----
                 The calculation for Cartesian coordinate is adapted from equations
 .28(b) and 2.28(c) of Doviak and Zrnic [1]_ assuming a
                 standard atmosphere (4/3 Earth's radius model).
                 .. math::
                     z = \\sqrt{r^2+R^2+2*r*R*sin(\\theta_e)} - R
                     s = R * arcsin(\\frac{r*cos(\\theta_e)}{R+z})
                     x = s * sin(\\theta_a)
                     y = s * cos(\\theta_a)
                 Where r is the distance from the radar to the center of the gate,
                 :math:`\\theta_a` is the azimuth angle, :math:`\\theta_e` is the
                 elevation angle, s is the arc length, and R is the effective radius
                 of the earth, taken to be 4/3 the mean radius of earth (6371 km).
                 References
                 ----------
                 .. [1] Doviak and Zrnic, Doppler Radar and Weather Observations, Second
                     Edition, 1993, p. 21.
                 """
                 theta_e = numpy.deg2rad(elevations) # elevation angle in radians.
                 theta_a = numpy.deg2rad(azimuths) # azimuth angle in radians.
                 R = 6371.0 * 1000.0 * 4.0 / 3.0     # effective radius of earth in meters.
                 r = ranges * 1000.0                 # distances to gates in meters.
                 z = (r ** 2 + R ** 2 + 2.0 * r * R * numpy.sin(theta_e)) ** 0.5 - R
                 s = R * numpy.arcsin(r * numpy.cos(theta_e) / (R + z))  # arc length in m.
                 x = s * numpy.sin(theta_a)
                 y = s * numpy.cos(theta_a)
                 return x, y, z
             def cartesian_to_geographic_aeqd(x, y, lon_0, lat_0, R=EARTH_RADIUS):
                 """
                 Azimuthal equidistant Cartesian to geographic coordinate transform.
                 Transform a set of Cartesian/Cartographic coordinates (x, y) to
                 geographic coordinate system (lat, lon) using a azimuthal equidistant
                 map projection [1]_.
                 .. math::
                     lat = \\arcsin(\\cos(c) * \\sin(lat_0) +
                                    (y * \\sin(c) * \\cos(lat_0) / \\rho))
                     lon = lon_0 + \\arctan2(
                         x * \\sin(c),
                         \\rho * \\cos(lat_0) * \\cos(c) - y * \\sin(lat_0) * \\sin(c))
                     \\rho = \\sqrt(x^2 + y^2)
                     c = \\rho / R
                 Where x, y are the Cartesian position from the center of projection;
                 lat, lon the corresponding latitude and longitude; lat_0, lon_0 are the
                 latitude and longitude of the center of the projection; R is the radius of
                 the earth (defaults to ~6371 km). lon is adjusted to be between -180 and
 .
                 Parameters
                 ----------
                 x, y : array-like
                     Cartesian coordinates in the same units as R, typically meters.
                 lon_0, lat_0 : float
                     Longitude and latitude, in degrees, of the center of the projection.
                 R : float, optional
                     Earth radius in the same units as x and y. The default value is in
                     units of meters.
                 Returns
                 -------
                 lon, lat : array
                     Longitude and latitude of Cartesian coordinates in degrees.
                 References
                 ----------
                 .. [1] Snyder, J. P. Map Projections--A Working Manual. U. S. Geological
                     Survey Professional Paper 1395, 1987, pp. 191-202.
                 """
                 x = numpy.atleast_1d(numpy.asarray(x))
                 y = numpy.atleast_1d(numpy.asarray(y))
                 lat_0_rad = numpy.deg2rad(lat_0)
                 lon_0_rad = numpy.deg2rad(lon_0)
                 rho = numpy.sqrt(x*x + y*y)
                 c = rho / R
                 with warnings.catch_warnings():
                     # division by zero may occur here but is properly addressed below so
                     # the warnings can be ignored
                     warnings.simplefilter("ignore", RuntimeWarning)
                     lat_rad = numpy.arcsin(numpy.cos(c) * numpy.sin(lat_0_rad) +
                                         y * numpy.sin(c) * numpy.cos(lat_0_rad) / rho)
                 lat_deg = numpy.rad2deg(lat_rad)
                 # fix cases where the distance from the center of the projection is zero
                 lat_deg[rho == 0] = lat_0
                 x1 = x * numpy.sin(c)
                 x2 = rho*numpy.cos(lat_0_rad)*numpy.cos(c) - y*numpy.sin(lat_0_rad)*numpy.sin(c)
                 lon_rad = lon_0_rad + numpy.arctan2(x1, x2)
                 lon_deg = numpy.rad2deg(lon_rad)
                 # Longitudes should be from -180 to 180 degrees
                 lon_deg[lon_deg > 180] -= 360.
                 lon_deg[lon_deg < -180] += 360.
                 return lon_deg, lat_deg
             def antenna_to_geographic(ranges, azimuths, elevations, site):
                 x, y, z = antenna_to_cartesian(numpy.array(ranges), numpy.array(azimuths), numpy.array(elevations))
                 lon, lat = cartesian_to_geographic_aeqd(x, y, site[0], site[1], R=6370997.)
                 return lon, lat
             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 WeatherParamsPlot(Plot):
                 plot_type = 'scattermap'
                 buffering = False
                 def setup(self):
                     self.ncols = 1
                     self.nrows = 1
                     self.nplots= 1
                     if self.channels is not None:
                         self.nplots = len(self.channels)
                         self.ncols = len(self.channels)
                     else:
                         self.nplots = self.data.shape(self.CODE)[0]
                         self.ncols = self.nplots
                         self.channels = list(range(self.nplots))
                     self.colorbar=True
                     if len(self.channels)>1:
                         self.width = 12
                     else:
                         self.width   =8
                     self.height  =7
                     self.ini     =0
                     self.len_azi =0
                     self.buffer_ini  = None
                     self.buffer_ele   = None
                     self.plots_adjust.update({'wspace': 0.4, 'hspace':0.4, 'left': 0.1, 'right': 0.9, 'bottom': 0.1})
                     self.flag    =0
                     self.indicador= 0
                     self.last_data_ele = None
                     self.val_mean      = None
                 def update(self, dataOut):
                     vars = {
                         'S' : 0,
                         'V' : 1,
                         'W' : 2,
                         'SNR' : 3,
                         'Z' : 4,
                         'D' : 5,
                         'P' : 6,
                         'R' : 7,
                     }
                     data = {}
                     meta = {}
-                    if hasattr(dataOut, 'nFFTPoints'):
+                    ##if hasattr(dataOut, 'nFFTPoints'):
-                        factor = dataOut.normFactor
+                    ##    factor = dataOut.normFactor*10.0 # CONSIDERACION ENTRE PULSE PAIR Y FFT
-                    else:
+                    ##else:
-                        factor = 1
+                    ##    factor = 1
                     if hasattr(dataOut, 'dparam'):
                         tmp = getattr(dataOut, 'data_param')
                     else:
                         #print("-------------------self.attr_data[0]",self.attr_data[0])
                         if 'S' in self.attr_data[0]:
                             if self.attr_data[0]=='S':
-                                tmp = 10*numpy.log10(10.0*getattr(dataOut, 'data_param')[:,0,:]/(factor))
+                                tmp = 10*numpy.log10(10.0*getattr(dataOut, 'data_param')[:,0,:]) ## /(factor))   ya no considerar factor se aplica factor jroproc_parametrs
                             if self.attr_data[0]=='SNR':
                                 tmp = 10*numpy.log10(getattr(dataOut, 'data_param')[:,3,:])
                         else:
                             tmp = getattr(dataOut, 'data_param')[:,vars[self.attr_data[0]],:]
                     if self.mask:
                         mask = dataOut.data_param[:,3,:] < self.mask
                         tmp[mask] = numpy.nan
                         mask = numpy.nansum((tmp, numpy.roll(tmp, 1),numpy.roll(tmp, -1)), axis=0) == tmp
                         tmp[mask] = numpy.nan
+                    ####################################################################
+                    #SE GUARDAN LOS DATOS DE LOS PARAMETROS YA SEA PP O SPECTRA EN UN ARCHIVO .npy
+                    ##elapsed_time = time.time() - self.start_time
+                    ##filename = f'{dataOut.inputUnit}_{self.attr_data[0]}_{elapsed_time:.0f}.npy'  # Nombre único con timestamp
+                    # Guardar el array en el nuevo archivo
+                    ##with open(filename, 'wb') as f:
+                    ##   numpy.save(f, tmp)
+                    ##print("Se creó el archivo:", filename)
+                    #####################################################################
                     r = dataOut.heightList
                     delta_height = r[1]-r[0]
                     valid = numpy.where(r>=0)[0]
                     data['r'] = numpy.arange(len(valid))*delta_height
                     data['data'] = [0, 0]
                     try:
                         data['data'][0] = tmp[0][:,valid]
                         data['data'][1] = tmp[1][:,valid]
                     except:
                         data['data'][0] = tmp[0][:,valid]
                         data['data'][1] = tmp[0][:,valid]
                     if dataOut.mode_op == 'PPI':
                         self.CODE = 'PPI'
                         self.title = self.CODE
                     elif dataOut.mode_op == 'RHI':
                         self.CODE = 'RHI'
                         self.title = self.CODE
                     data['azi'] = dataOut.data_azi
                     data['ele'] = dataOut.data_ele
                     if isinstance(dataOut.mode_op, bytes):
                         try:
                             dataOut.mode_op = dataOut.mode_op.decode()
                         except:
                             dataOut.mode_op = str(dataOut.mode_op, 'utf-8')
                     data['mode_op'] = dataOut.mode_op
                     self.mode = dataOut.mode_op
                     return data, meta
                 def plot(self):
                     data = self.data[-1]
                     z = data['data']
                     r = data['r']
                     self.titles = []
                     self.zmax = self.zmax if self.zmax else numpy.nanmax(z)
                     self.zmin = self.zmin if self.zmin is not None else numpy.nanmin(z)
                     if isinstance(data['mode_op'], bytes):
                         data['mode_op'] = data['mode_op'].decode()
                     if data['mode_op'] == 'RHI':
                         r, theta = numpy.meshgrid(r, numpy.radians(data['ele']))
                         len_aux = int(data['azi'].shape[0]/4)
                         mean = numpy.mean(data['azi'][len_aux:-len_aux])
                         x, y = r*numpy.cos(theta), r*numpy.sin(theta)
                         if self.yrange:
                             self.ylabel= 'Height [km]'
                             self.xlabel= 'Distance from radar [km]'
                             self.ymax = self.yrange
                             self.ymin = 0
                             self.xmax = self.xrange if self.xrange else numpy.nanmax(r)
                             self.xmin = -self.xrange if self.xrange else -numpy.nanmax(r)
                             self.setrhilimits = False
                         else:
                             self.ymin = 0
                             self.ymax = numpy.nanmax(r)
                             self.xmin = -numpy.nanmax(r)
                             self.xmax = numpy.nanmax(r)
                     elif data['mode_op'] == 'PPI':
                         r, theta = numpy.meshgrid(r, -numpy.radians(data['azi'])+numpy.pi/2)
                         len_aux = int(data['ele'].shape[0]/4)
                         mean = numpy.mean(data['ele'][len_aux:-len_aux])
                         x, y = r*numpy.cos(theta)*numpy.cos(numpy.radians(mean)), r*numpy.sin(
                                 theta)*numpy.cos(numpy.radians(mean))
                         x = km2deg(x) + self.longitude
                         y = km2deg(y) + self.latitude
                         if self.xrange:
                             self.ylabel= 'Latitude'
                             self.xlabel= 'Longitude'
                             self.xmin = km2deg(-self.xrange) + self.longitude
                             self.xmax = km2deg(self.xrange) + self.longitude
                             self.ymin = km2deg(-self.xrange) + self.latitude
                             self.ymax = km2deg(self.xrange) + self.latitude
                         else:
                             self.xmin = km2deg(-numpy.nanmax(r)) + self.longitude
                             self.xmax = km2deg(numpy.nanmax(r)) + self.longitude
                             self.ymin = km2deg(-numpy.nanmax(r)) + self.latitude
                             self.ymax = km2deg(numpy.nanmax(r)) + self.latitude
                     self.clear_figures()
                     if data['mode_op'] == 'PPI':
                         axes = self.axes['PPI']
                     else:
                         axes = self.axes['RHI']
                     if self.colormap in cb_tables:
                         norm = cb_tables[self.colormap]['norm']
                     else:
                         norm = None
                     for i, ax in enumerate(axes):
                         if norm is None:
                             ax.plt = ax.pcolormesh(x, y, z[i], cmap=self.colormap, vmin=self.zmin, vmax=self.zmax)
                         else:
                             ax.plt = ax.pcolormesh(x, y, z[i], cmap=self.colormap, norm=norm)
                         if data['mode_op'] == 'RHI':
                             len_aux = int(data['azi'].shape[0]/4)
                             mean = numpy.mean(data['azi'][len_aux:-len_aux])
                             if len(self.channels) !=1:
                                 self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[x], str(round(mean,1)), x) for x in self.channels]
                             else:
                                 self.titles = ['RHI {} at AZ: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
                         elif data['mode_op'] == 'PPI':
                             len_aux = int(data['ele'].shape[0]/4)
                             mean = numpy.mean(data['ele'][len_aux:-len_aux])
                             if len(self.channels) !=1:
                                 self.titles = ['PPI {} at EL: {} CH {}'.format(self.labels[x], str(round(mean,1)), x) for x in self.channels]
                             else:
                                 self.titles = ['PPI {} at EL: {} CH {}'.format(self.labels[0], str(round(mean,1)), self.channels[0])]
                         self.mode_value = round(mean,1)
                         if data['mode_op'] == 'PPI':
                             if self.map:
                                 gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
                                 linewidth=1, color='gray', alpha=0.5, linestyle='--')
                                 gl.xlabel_style = {'size': 8}
                                 gl.ylabel_style = {'size': 8}
                                 gl.xlabels_top = False
                                 gl.ylabels_right = False
                                 shape_d = os.path.join(self.shapes,'Distritos/PER_adm3.shp')
                                 shape_p = os.path.join(self.shapes,'PER_ADM2/PER_ADM2.shp')
                                 capitales = os.path.join(self.shapes,'CAPITALES/cap_distrito.shp')
                                 vias = os.path.join(self.shapes,'Carreteras/VIAS_NACIONAL_250000.shp')
                                 reader_d = shpreader.BasicReader(shape_d, encoding='latin1')
                                 reader_p = shpreader.BasicReader(shape_p, encoding='latin1')
                                 reader_c = shpreader.BasicReader(capitales, encoding='latin1')
                                 reader_v = shpreader.BasicReader(vias, encoding='latin1')
                                 caps = [x for x in reader_c.records() if x.attributes['DEPARTA']=='PIURA' and x.attributes['CATEGORIA']=='CIUDAD']
                                 districts = [x for x in reader_d.records() if x.attributes['NAME_1']=='Piura']
                                 provs = [x for x in reader_p.records()]
                                 vias = [x for x in reader_v.records()]
                                 # Display limits and streets
                                 shape_feature = ShapelyFeature([x.geometry for x in districts], ccrs.PlateCarree(), facecolor="none", edgecolor='grey', lw=0.5)
                                 ax.add_feature(shape_feature)
                                 shape_feature = ShapelyFeature([x.geometry for x in provs], ccrs.PlateCarree(), facecolor="none", edgecolor='white', lw=1)
                                 ax.add_feature(shape_feature)
                                 shape_feature = ShapelyFeature([x.geometry for x in vias], ccrs.PlateCarree(), facecolor="none", edgecolor='yellow', lw=1)
                                 ax.add_feature(shape_feature)
                                 for cap in caps:
                                     if cap.attributes['NOMBRE'] in ('PIURA', 'SULLANA', 'PAITA', 'SECHURA', 'TALARA'):
                                         ax.text(cap.attributes['X'], cap.attributes['Y'], cap.attributes['NOMBRE'], size=8, color='white', weight='bold')
                                     elif cap.attributes['NOMBRE'] in ('NEGRITOS', 'SAN LUCAS', 'QUERECOTILLO', 'TAMBO GRANDE', 'CHULUCANAS', 'CATACAOS', 'LA UNION'):
                                         ax.text(cap.attributes['X'], cap.attributes['Y'], cap.attributes['NOMBRE'].title(), size=7, color='white')
                             else:
                                 ax.grid(color='grey', alpha=0.5, linestyle='--', linewidth=1)
                             if self.xrange<=10:
                                 ranges = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
                             elif self.xrange<=30:
                                 ranges = [5, 10, 15, 20, 25, 30, 35]
                             elif self.xrange<=60:
                                 ranges = [10, 20, 30, 40, 50, 60]
                             elif self.xrange<=100:
                                 ranges = [15, 30, 45, 60, 75, 90]
                             for R in ranges:
                                 if R <= self.xrange:
                                     circle = Circle((self.longitude, self.latitude), km2deg(R), facecolor='none',
                                         edgecolor='skyblue', linewidth=1, alpha=0.5)
                                     ax.add_patch(circle)
                                     ax.text(km2deg(R)*numpy.cos(numpy.radians(45))+self.longitude,
                                         km2deg(R)*numpy.sin(numpy.radians(45))+self.latitude,
                                         '{}km'.format(R), color='skyblue', size=7)
                         elif data['mode_op'] == 'RHI':
                             ax.grid(color='grey', alpha=0.5, linestyle='--', linewidth=1)

schainpy/model/io/jroIO_digitalRF.py +2 0

             '''
             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:
                 os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
                 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
                     if not self.getByBlock:
                         nProfiles = 1.0 / ippSeconds  # Number of profiles in one second
                     else:
                         nProfiles = self.nProfileBlocks # Number of profiles in one block
                     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)))
                     if not self.getByBlock:
                         self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights
                     else:
                         self.dataOut.blocksize   = self.dataOut.nChannels * self.dataOut.nHeights*self.nProfileBlocks
                     # self.dataOut.channelIndexList = None
                     self.dataOut.flagNoData      = True
                     if not self.getByBlock:
                         self.dataOut.flagDataAsBlock = False
                     else:
                         self.dataOut.flagDataAsBlock = True
                     # 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=int),
                           getByBlock=0,
                           nProfileBlocks=1,
                           **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
                     self.getByBlock     = getByBlock
                     self.nProfileBlocks = nProfileBlocks
                     if online:
                         print('Waiting for RF data..')
                         sleep(40)
                     if not os.path.isdir(path):
                         raise ValueError("[Reading] Directory %s does not exist" % path)
                     #print("path",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.__frequency = 9.345e9
                     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
                     start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
                     if start_index==None or end_index==None:
                          print("Check error No data,  start_index: ",start_index,",end_index: ",end_index)
                          #return 0
                     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 #Check UTC and LT time
                     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
                     if self.getByBlock:
                         nSamples = nSamples*nProfileBlocks
                     self.__samples_to_read  = int(nSamples)  # FIJO: AHORA 40
                     self.__nChannels        = len(self.__channelList)
                     #print("------------------------------------------")
                     #print("self.__samples_to_read",self.__samples_to_read)
                     #print("self.__nSamples",self.__nSamples)
                     # son iguales y el buffer_index da 0
                     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)
                     print("samplestoread",self.__samples_to_read)
                     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/20000.0):
                     '''
                     NOTA: APLICACION RADAR METEOROLOGICO
                     VALORES OBTENIDOS CON LA USRP, volt_scale = 1,conexion directa al Ch Rx.
                     MAXIMO
 -> 0.980 Voltiospp
 -> 0.480 Voltiospp
 -> 1.440 Voltiospp
 -> 1.940 Voltiospp
                     Para llevar al valor correspondiente de Voltaje, debemos dividir por 20000
                     y obtenemos la Amplitud correspondiente de entrada IQ.
                     volt_scale = (1/20000.0)
                     '''
                     # 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()
                                 #print("thisUNixSample",self.__thisUnixSample)
                                 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
                                                                               self.__samples_to_read,
                                                                               thisChannelName, sub_channel=indexSubchannel)
                                 #print("result--------------",result)
                                 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)
                                 bot = 0
                                 while(self.__flagDiscontinuousBlock):
                                     bot +=1
                                     self.__thisUnixSample += self.__samples_to_read
                                     try:
                                         result = result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,self.__samples_to_read,thisChannelName, sub_channel=indexSubchannel)
                                         self.__flagDiscontinuousBlock=False
                                         print("Searching.. N°: ",bot,"Success",self.__thisUnixSample)
                                     except:
                                         print("Searching...N°: ",bot,"Fail", self.__thisUnixSample)
                                 if self.__flagDiscontinuousBlock==True:
                                     break
                                 else:
                                     print("New data index found...",self.__thisUnixSample)
                                 #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:
                             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)
                         if not self.getByBlock:
                             #print("self.__bufferIndex",self.__bufferIndex)# este valor siempre es cero aparentemente
                             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
                         else:
                             # ojo debo anadir el readNextBLock y el  __isBufferEmpty(
                             self.dataOut.flagNoData             = False
                             buffer = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex + self.__samples_to_read]
                             buffer = buffer.reshape((self.__nChannels, self.nProfileBlocks, int(self.__samples_to_read/self.nProfileBlocks)))
                             self.dataOut.nProfileBlocks = self.nProfileBlocks
                             self.dataOut.data = buffer
                             self.dataOut.utctime = ( self.__thisUnixSample + self.__bufferIndex) / self.__sample_rate
                             self.profileIndex  += self.__samples_to_read
                             self.__bufferIndex += self.__samples_to_read
                             self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
                         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.getData(seconds=self.__delay)
                     return
             @MPDecorator
             class DigitalRFWriter(Operation):
                 '''
                 classdocs
                 '''
                 def __init__(self, **kwargs):
                     '''
                     Constructor
                     '''
                     Operation.__init__(self, **kwargs)
                     self.metadata_dict = {}
                     self.dataOut       = None
                     self.dtype         = None
                     self.oldAverage    = 0
                 def setHeader(self):
                     self.metadata_dict['frequency']      = self.dataOut.frequency
                     self.metadata_dict['timezone']       = self.dataOut.timeZone
                     self.metadata_dict['dtype']          = pickle.dumps(self.dataOut.dtype)
                     self.metadata_dict['nProfiles']      = self.dataOut.nProfiles
                     self.metadata_dict['heightList']     = self.dataOut.heightList
                     self.metadata_dict['channelList']    = self.dataOut.channelList
                     self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
                     self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
                     self.metadata_dict['flagShiftFFT']   = self.dataOut.flagShiftFFT
                     self.metadata_dict['useLocalTime']   = self.dataOut.useLocalTime
                     self.metadata_dict['nCohInt']        = self.dataOut.nCohInt
                     self.metadata_dict['type']           = self.dataOut.type
                     self.metadata_dict['flagDataAsBlock']= getattr(
                         self.dataOut, 'flagDataAsBlock', None)  # chequear
                 def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
                     '''
                     In this method we should set all initial parameters.
                     Input:
                         dataOut: Input data will also be outputa data
                     '''
                     self.setHeader()
                     self.__ippSeconds  = dataOut.ippSeconds
                     self.__deltaH      = dataOut.getDeltaH()
                     self.__sample_rate = 1e6 * 0.15 / self.__deltaH
                     self.__dtype       = dataOut.dtype
                     if len(dataOut.dtype) == 2:
                         self.__dtype = dataOut.dtype[0]
                     self.__nSamples  = dataOut.systemHeaderObj.nSamples
                     self.__nProfiles = dataOut.nProfiles
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     else:
                         self.arr_data = numpy.ones((self.__nSamples, len(
                             self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
                     file_cadence_millisecs  = 1000
                     sample_rate_fraction    = Fraction(self.__sample_rate).limit_denominator()
                     sample_rate_numerator   = int(sample_rate_fraction.numerator)
                     sample_rate_denominator = int(sample_rate_fraction.denominator)
                     start_global_index      = dataOut.utctime * self.__sample_rate
                     uuid              = 'prueba'
                     compression_level = 0
                     checksum          = False
                     is_complex        = True
                     num_subchannels   = len(dataOut.channelList)
                     is_continuous     = True
                     marching_periods  = False
                     self.digitalWriteObj = digital_rf.DigitalRFWriter(path, self.__dtype, dirCadence,
                                                                       fileCadence, start_global_index,
                                                                       sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                                       is_complex, num_subchannels, is_continuous, marching_periods)
                     metadata_dir         = os.path.join(path, 'metadata')
                     os.system('mkdir %s' % (metadata_dir))
                     self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                                     sample_rate_numerator, sample_rate_denominator,
                                                                                     metadataFile)
                     self.isConfig      = True
                     self.currentSample = 0
                     self.oldAverage    = 0
                     self.count         = 0
                     return
                 def writeMetadata(self):
                     start_idx                                   = self.__sample_rate * self.dataOut.utctime
                     self.metadata_dict['processingHeader']      = self.dataOut.processingHeaderObj.getAsDict(
                     )
                     self.metadata_dict['radarControllerHeader'] = self.dataOut.radarControllerHeaderObj.getAsDict(
                     )
                     self.metadata_dict['systemHeader']          = self.dataOut.systemHeaderObj.getAsDict(
                     )
                     self.digitalMetadataWriteObj.write(start_idx, self.metadata_dict)
                     return
                 def timeit(self, toExecute):
                     t0 = time()
                     toExecute()
                     self.executionTime  = time() - t0
                     if self.oldAverage is None:
                         self.oldAverage = self.executionTime
                     self.oldAverage     = (self.executionTime + self.count *
                                        self.oldAverage) / (self.count + 1.0)
                     self.count          = self.count + 1.0
                     return
                 def writeData(self):
                     if self.dataOut.type != 'Voltage':
                         raise 'Digital RF cannot be used with this data type'
                         for channel in self.dataOut.channelList:
                             for i in range(self.dataOut.nFFTPoints):
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[1][channel * self.dataOut.nFFTPoints +
                                                  i]['i'] = self.dataOut.data[channel][i].imag
                     else:
                         for i in range(self.dataOut.systemHeaderObj.nSamples):
                             for channel in self.dataOut.channelList:
                                 self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
                                 self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
                     def f(): return self.digitalWriteObj.rf_write(self.arr_data)
                     self.timeit(f)
                     return
                 def run(self, dataOut, frequency=49.92e6, path=None, fileCadence=1000, dirCadence=36000, metadataCadence=1, **kwargs):
                     '''
                     This method will be called many times so here you should put all your code
                     Inputs:
                         dataOut: object with the data
                     '''
                     # print dataOut.__dict__
                     self.dataOut = dataOut
                     if not self.isConfig:
                         self.setup(dataOut, path, frequency, fileCadence,
                                    dirCadence, metadataCadence, **kwargs)
                         self.writeMetadata()
                     self.writeData()
                     ## self.currentSample += 1
                     # if self.dataOut.flagDataAsBlock or self.currentSample == 1:
                     # self.writeMetadata()
                     ## if self.currentSample == self.__nProfiles: self.currentSample = 0
                     return dataOut# en la version 2.7 no aparece este return
                 def close(self):
                     print('[Writing] - Closing files ')
                     print('Average of writing to digital rf format is ', self.oldAverage * 1000)
                     try:
                         self.digitalWriteObj.close()
                     except:
                         pass

schainpy/model/proc/jroproc_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

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